﻿// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT License.
// See the LICENSE file in the project root for more information.

//
// Revision history:
//
//   PS - 10/17/2014 - Wrote these tests.
//

using Microsoft.VisualStudio.TestTools.UnitTesting;
using System;
using System.Collections.Specialized;

namespace Tests.System.Collections.Specialized
{
    public partial class EnumDictionaryFactoryTests
    {
        [TestMethod]
        public void EnumDictionaryFactory_Underlying_BitArray()
        {
            var dict0 = EnumDictionary.Create<E0, bool>();
            var expectedBitArray0 = BitArrayFactory.Create(0).GetType();
            var actualBitArray0 = dict0.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray0, actualBitArray0);

            var dict1 = EnumDictionary.Create<E1, bool>();
            var expectedBitArray1 = BitArrayFactory.Create(1).GetType();
            var actualBitArray1 = dict1.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray1, actualBitArray1);

            var dict2 = EnumDictionary.Create<E2, bool>();
            var expectedBitArray2 = BitArrayFactory.Create(2).GetType();
            var actualBitArray2 = dict2.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray2, actualBitArray2);

            var dict3 = EnumDictionary.Create<E3, bool>();
            var expectedBitArray3 = BitArrayFactory.Create(3).GetType();
            var actualBitArray3 = dict3.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray3, actualBitArray3);

            var dict4 = EnumDictionary.Create<E4, bool>();
            var expectedBitArray4 = BitArrayFactory.Create(4).GetType();
            var actualBitArray4 = dict4.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray4, actualBitArray4);

            var dict5 = EnumDictionary.Create<E5, bool>();
            var expectedBitArray5 = BitArrayFactory.Create(5).GetType();
            var actualBitArray5 = dict5.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray5, actualBitArray5);

            var dict6 = EnumDictionary.Create<E6, bool>();
            var expectedBitArray6 = BitArrayFactory.Create(6).GetType();
            var actualBitArray6 = dict6.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray6, actualBitArray6);

            var dict7 = EnumDictionary.Create<E7, bool>();
            var expectedBitArray7 = BitArrayFactory.Create(7).GetType();
            var actualBitArray7 = dict7.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray7, actualBitArray7);

            var dict8 = EnumDictionary.Create<E8, bool>();
            var expectedBitArray8 = BitArrayFactory.Create(8).GetType();
            var actualBitArray8 = dict8.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray8, actualBitArray8);

            var dict9 = EnumDictionary.Create<E9, bool>();
            var expectedBitArray9 = BitArrayFactory.Create(9).GetType();
            var actualBitArray9 = dict9.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray9, actualBitArray9);

            var dict10 = EnumDictionary.Create<E10, bool>();
            var expectedBitArray10 = BitArrayFactory.Create(10).GetType();
            var actualBitArray10 = dict10.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray10, actualBitArray10);

            var dict11 = EnumDictionary.Create<E11, bool>();
            var expectedBitArray11 = BitArrayFactory.Create(11).GetType();
            var actualBitArray11 = dict11.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray11, actualBitArray11);

            var dict12 = EnumDictionary.Create<E12, bool>();
            var expectedBitArray12 = BitArrayFactory.Create(12).GetType();
            var actualBitArray12 = dict12.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray12, actualBitArray12);

            var dict13 = EnumDictionary.Create<E13, bool>();
            var expectedBitArray13 = BitArrayFactory.Create(13).GetType();
            var actualBitArray13 = dict13.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray13, actualBitArray13);

            var dict14 = EnumDictionary.Create<E14, bool>();
            var expectedBitArray14 = BitArrayFactory.Create(14).GetType();
            var actualBitArray14 = dict14.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray14, actualBitArray14);

            var dict15 = EnumDictionary.Create<E15, bool>();
            var expectedBitArray15 = BitArrayFactory.Create(15).GetType();
            var actualBitArray15 = dict15.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray15, actualBitArray15);

            var dict16 = EnumDictionary.Create<E16, bool>();
            var expectedBitArray16 = BitArrayFactory.Create(16).GetType();
            var actualBitArray16 = dict16.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray16, actualBitArray16);

            var dict17 = EnumDictionary.Create<E17, bool>();
            var expectedBitArray17 = BitArrayFactory.Create(17).GetType();
            var actualBitArray17 = dict17.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray17, actualBitArray17);

            var dict18 = EnumDictionary.Create<E18, bool>();
            var expectedBitArray18 = BitArrayFactory.Create(18).GetType();
            var actualBitArray18 = dict18.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray18, actualBitArray18);

            var dict19 = EnumDictionary.Create<E19, bool>();
            var expectedBitArray19 = BitArrayFactory.Create(19).GetType();
            var actualBitArray19 = dict19.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray19, actualBitArray19);

            var dict20 = EnumDictionary.Create<E20, bool>();
            var expectedBitArray20 = BitArrayFactory.Create(20).GetType();
            var actualBitArray20 = dict20.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray20, actualBitArray20);

            var dict21 = EnumDictionary.Create<E21, bool>();
            var expectedBitArray21 = BitArrayFactory.Create(21).GetType();
            var actualBitArray21 = dict21.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray21, actualBitArray21);

            var dict22 = EnumDictionary.Create<E22, bool>();
            var expectedBitArray22 = BitArrayFactory.Create(22).GetType();
            var actualBitArray22 = dict22.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray22, actualBitArray22);

            var dict23 = EnumDictionary.Create<E23, bool>();
            var expectedBitArray23 = BitArrayFactory.Create(23).GetType();
            var actualBitArray23 = dict23.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray23, actualBitArray23);

            var dict24 = EnumDictionary.Create<E24, bool>();
            var expectedBitArray24 = BitArrayFactory.Create(24).GetType();
            var actualBitArray24 = dict24.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray24, actualBitArray24);

            var dict25 = EnumDictionary.Create<E25, bool>();
            var expectedBitArray25 = BitArrayFactory.Create(25).GetType();
            var actualBitArray25 = dict25.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray25, actualBitArray25);

            var dict26 = EnumDictionary.Create<E26, bool>();
            var expectedBitArray26 = BitArrayFactory.Create(26).GetType();
            var actualBitArray26 = dict26.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray26, actualBitArray26);

            var dict27 = EnumDictionary.Create<E27, bool>();
            var expectedBitArray27 = BitArrayFactory.Create(27).GetType();
            var actualBitArray27 = dict27.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray27, actualBitArray27);

            var dict28 = EnumDictionary.Create<E28, bool>();
            var expectedBitArray28 = BitArrayFactory.Create(28).GetType();
            var actualBitArray28 = dict28.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray28, actualBitArray28);

            var dict29 = EnumDictionary.Create<E29, bool>();
            var expectedBitArray29 = BitArrayFactory.Create(29).GetType();
            var actualBitArray29 = dict29.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray29, actualBitArray29);

            var dict30 = EnumDictionary.Create<E30, bool>();
            var expectedBitArray30 = BitArrayFactory.Create(30).GetType();
            var actualBitArray30 = dict30.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray30, actualBitArray30);

            var dict31 = EnumDictionary.Create<E31, bool>();
            var expectedBitArray31 = BitArrayFactory.Create(31).GetType();
            var actualBitArray31 = dict31.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray31, actualBitArray31);

            var dict32 = EnumDictionary.Create<E32, bool>();
            var expectedBitArray32 = BitArrayFactory.Create(32).GetType();
            var actualBitArray32 = dict32.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray32, actualBitArray32);

            var dict33 = EnumDictionary.Create<E33, bool>();
            var expectedBitArray33 = BitArrayFactory.Create(33).GetType();
            var actualBitArray33 = dict33.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray33, actualBitArray33);

            var dict34 = EnumDictionary.Create<E34, bool>();
            var expectedBitArray34 = BitArrayFactory.Create(34).GetType();
            var actualBitArray34 = dict34.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray34, actualBitArray34);

            var dict35 = EnumDictionary.Create<E35, bool>();
            var expectedBitArray35 = BitArrayFactory.Create(35).GetType();
            var actualBitArray35 = dict35.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray35, actualBitArray35);

            var dict36 = EnumDictionary.Create<E36, bool>();
            var expectedBitArray36 = BitArrayFactory.Create(36).GetType();
            var actualBitArray36 = dict36.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray36, actualBitArray36);

            var dict37 = EnumDictionary.Create<E37, bool>();
            var expectedBitArray37 = BitArrayFactory.Create(37).GetType();
            var actualBitArray37 = dict37.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray37, actualBitArray37);

            var dict38 = EnumDictionary.Create<E38, bool>();
            var expectedBitArray38 = BitArrayFactory.Create(38).GetType();
            var actualBitArray38 = dict38.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray38, actualBitArray38);

            var dict39 = EnumDictionary.Create<E39, bool>();
            var expectedBitArray39 = BitArrayFactory.Create(39).GetType();
            var actualBitArray39 = dict39.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray39, actualBitArray39);

            var dict40 = EnumDictionary.Create<E40, bool>();
            var expectedBitArray40 = BitArrayFactory.Create(40).GetType();
            var actualBitArray40 = dict40.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray40, actualBitArray40);

            var dict41 = EnumDictionary.Create<E41, bool>();
            var expectedBitArray41 = BitArrayFactory.Create(41).GetType();
            var actualBitArray41 = dict41.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray41, actualBitArray41);

            var dict42 = EnumDictionary.Create<E42, bool>();
            var expectedBitArray42 = BitArrayFactory.Create(42).GetType();
            var actualBitArray42 = dict42.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray42, actualBitArray42);

            var dict43 = EnumDictionary.Create<E43, bool>();
            var expectedBitArray43 = BitArrayFactory.Create(43).GetType();
            var actualBitArray43 = dict43.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray43, actualBitArray43);

            var dict44 = EnumDictionary.Create<E44, bool>();
            var expectedBitArray44 = BitArrayFactory.Create(44).GetType();
            var actualBitArray44 = dict44.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray44, actualBitArray44);

            var dict45 = EnumDictionary.Create<E45, bool>();
            var expectedBitArray45 = BitArrayFactory.Create(45).GetType();
            var actualBitArray45 = dict45.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray45, actualBitArray45);

            var dict46 = EnumDictionary.Create<E46, bool>();
            var expectedBitArray46 = BitArrayFactory.Create(46).GetType();
            var actualBitArray46 = dict46.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray46, actualBitArray46);

            var dict47 = EnumDictionary.Create<E47, bool>();
            var expectedBitArray47 = BitArrayFactory.Create(47).GetType();
            var actualBitArray47 = dict47.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray47, actualBitArray47);

            var dict48 = EnumDictionary.Create<E48, bool>();
            var expectedBitArray48 = BitArrayFactory.Create(48).GetType();
            var actualBitArray48 = dict48.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray48, actualBitArray48);

            var dict49 = EnumDictionary.Create<E49, bool>();
            var expectedBitArray49 = BitArrayFactory.Create(49).GetType();
            var actualBitArray49 = dict49.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray49, actualBitArray49);

            var dict50 = EnumDictionary.Create<E50, bool>();
            var expectedBitArray50 = BitArrayFactory.Create(50).GetType();
            var actualBitArray50 = dict50.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray50, actualBitArray50);

            var dict51 = EnumDictionary.Create<E51, bool>();
            var expectedBitArray51 = BitArrayFactory.Create(51).GetType();
            var actualBitArray51 = dict51.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray51, actualBitArray51);

            var dict52 = EnumDictionary.Create<E52, bool>();
            var expectedBitArray52 = BitArrayFactory.Create(52).GetType();
            var actualBitArray52 = dict52.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray52, actualBitArray52);

            var dict53 = EnumDictionary.Create<E53, bool>();
            var expectedBitArray53 = BitArrayFactory.Create(53).GetType();
            var actualBitArray53 = dict53.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray53, actualBitArray53);

            var dict54 = EnumDictionary.Create<E54, bool>();
            var expectedBitArray54 = BitArrayFactory.Create(54).GetType();
            var actualBitArray54 = dict54.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray54, actualBitArray54);

            var dict55 = EnumDictionary.Create<E55, bool>();
            var expectedBitArray55 = BitArrayFactory.Create(55).GetType();
            var actualBitArray55 = dict55.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray55, actualBitArray55);

            var dict56 = EnumDictionary.Create<E56, bool>();
            var expectedBitArray56 = BitArrayFactory.Create(56).GetType();
            var actualBitArray56 = dict56.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray56, actualBitArray56);

            var dict57 = EnumDictionary.Create<E57, bool>();
            var expectedBitArray57 = BitArrayFactory.Create(57).GetType();
            var actualBitArray57 = dict57.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray57, actualBitArray57);

            var dict58 = EnumDictionary.Create<E58, bool>();
            var expectedBitArray58 = BitArrayFactory.Create(58).GetType();
            var actualBitArray58 = dict58.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray58, actualBitArray58);

            var dict59 = EnumDictionary.Create<E59, bool>();
            var expectedBitArray59 = BitArrayFactory.Create(59).GetType();
            var actualBitArray59 = dict59.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray59, actualBitArray59);

            var dict60 = EnumDictionary.Create<E60, bool>();
            var expectedBitArray60 = BitArrayFactory.Create(60).GetType();
            var actualBitArray60 = dict60.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray60, actualBitArray60);

            var dict61 = EnumDictionary.Create<E61, bool>();
            var expectedBitArray61 = BitArrayFactory.Create(61).GetType();
            var actualBitArray61 = dict61.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray61, actualBitArray61);

            var dict62 = EnumDictionary.Create<E62, bool>();
            var expectedBitArray62 = BitArrayFactory.Create(62).GetType();
            var actualBitArray62 = dict62.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray62, actualBitArray62);

            var dict63 = EnumDictionary.Create<E63, bool>();
            var expectedBitArray63 = BitArrayFactory.Create(63).GetType();
            var actualBitArray63 = dict63.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray63, actualBitArray63);

            var dict64 = EnumDictionary.Create<E64, bool>();
            var expectedBitArray64 = BitArrayFactory.Create(64).GetType();
            var actualBitArray64 = dict64.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray64, actualBitArray64);

            var dict65 = EnumDictionary.Create<E65, bool>();
            var expectedBitArray65 = BitArrayFactory.Create(65).GetType();
            var actualBitArray65 = dict65.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray65, actualBitArray65);

            var dict66 = EnumDictionary.Create<E66, bool>();
            var expectedBitArray66 = BitArrayFactory.Create(66).GetType();
            var actualBitArray66 = dict66.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray66, actualBitArray66);

            var dict67 = EnumDictionary.Create<E67, bool>();
            var expectedBitArray67 = BitArrayFactory.Create(67).GetType();
            var actualBitArray67 = dict67.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray67, actualBitArray67);

            var dict68 = EnumDictionary.Create<E68, bool>();
            var expectedBitArray68 = BitArrayFactory.Create(68).GetType();
            var actualBitArray68 = dict68.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray68, actualBitArray68);

            var dict69 = EnumDictionary.Create<E69, bool>();
            var expectedBitArray69 = BitArrayFactory.Create(69).GetType();
            var actualBitArray69 = dict69.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray69, actualBitArray69);

            var dict70 = EnumDictionary.Create<E70, bool>();
            var expectedBitArray70 = BitArrayFactory.Create(70).GetType();
            var actualBitArray70 = dict70.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray70, actualBitArray70);

            var dict71 = EnumDictionary.Create<E71, bool>();
            var expectedBitArray71 = BitArrayFactory.Create(71).GetType();
            var actualBitArray71 = dict71.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray71, actualBitArray71);

            var dict72 = EnumDictionary.Create<E72, bool>();
            var expectedBitArray72 = BitArrayFactory.Create(72).GetType();
            var actualBitArray72 = dict72.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray72, actualBitArray72);

            var dict73 = EnumDictionary.Create<E73, bool>();
            var expectedBitArray73 = BitArrayFactory.Create(73).GetType();
            var actualBitArray73 = dict73.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray73, actualBitArray73);

            var dict74 = EnumDictionary.Create<E74, bool>();
            var expectedBitArray74 = BitArrayFactory.Create(74).GetType();
            var actualBitArray74 = dict74.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray74, actualBitArray74);

            var dict75 = EnumDictionary.Create<E75, bool>();
            var expectedBitArray75 = BitArrayFactory.Create(75).GetType();
            var actualBitArray75 = dict75.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray75, actualBitArray75);

            var dict76 = EnumDictionary.Create<E76, bool>();
            var expectedBitArray76 = BitArrayFactory.Create(76).GetType();
            var actualBitArray76 = dict76.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray76, actualBitArray76);

            var dict77 = EnumDictionary.Create<E77, bool>();
            var expectedBitArray77 = BitArrayFactory.Create(77).GetType();
            var actualBitArray77 = dict77.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray77, actualBitArray77);

            var dict78 = EnumDictionary.Create<E78, bool>();
            var expectedBitArray78 = BitArrayFactory.Create(78).GetType();
            var actualBitArray78 = dict78.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray78, actualBitArray78);

            var dict79 = EnumDictionary.Create<E79, bool>();
            var expectedBitArray79 = BitArrayFactory.Create(79).GetType();
            var actualBitArray79 = dict79.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray79, actualBitArray79);

            var dict80 = EnumDictionary.Create<E80, bool>();
            var expectedBitArray80 = BitArrayFactory.Create(80).GetType();
            var actualBitArray80 = dict80.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray80, actualBitArray80);

            var dict81 = EnumDictionary.Create<E81, bool>();
            var expectedBitArray81 = BitArrayFactory.Create(81).GetType();
            var actualBitArray81 = dict81.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray81, actualBitArray81);

            var dict82 = EnumDictionary.Create<E82, bool>();
            var expectedBitArray82 = BitArrayFactory.Create(82).GetType();
            var actualBitArray82 = dict82.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray82, actualBitArray82);

            var dict83 = EnumDictionary.Create<E83, bool>();
            var expectedBitArray83 = BitArrayFactory.Create(83).GetType();
            var actualBitArray83 = dict83.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray83, actualBitArray83);

            var dict84 = EnumDictionary.Create<E84, bool>();
            var expectedBitArray84 = BitArrayFactory.Create(84).GetType();
            var actualBitArray84 = dict84.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray84, actualBitArray84);

            var dict85 = EnumDictionary.Create<E85, bool>();
            var expectedBitArray85 = BitArrayFactory.Create(85).GetType();
            var actualBitArray85 = dict85.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray85, actualBitArray85);

            var dict86 = EnumDictionary.Create<E86, bool>();
            var expectedBitArray86 = BitArrayFactory.Create(86).GetType();
            var actualBitArray86 = dict86.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray86, actualBitArray86);

            var dict87 = EnumDictionary.Create<E87, bool>();
            var expectedBitArray87 = BitArrayFactory.Create(87).GetType();
            var actualBitArray87 = dict87.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray87, actualBitArray87);

            var dict88 = EnumDictionary.Create<E88, bool>();
            var expectedBitArray88 = BitArrayFactory.Create(88).GetType();
            var actualBitArray88 = dict88.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray88, actualBitArray88);

            var dict89 = EnumDictionary.Create<E89, bool>();
            var expectedBitArray89 = BitArrayFactory.Create(89).GetType();
            var actualBitArray89 = dict89.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray89, actualBitArray89);

            var dict90 = EnumDictionary.Create<E90, bool>();
            var expectedBitArray90 = BitArrayFactory.Create(90).GetType();
            var actualBitArray90 = dict90.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray90, actualBitArray90);

            var dict91 = EnumDictionary.Create<E91, bool>();
            var expectedBitArray91 = BitArrayFactory.Create(91).GetType();
            var actualBitArray91 = dict91.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray91, actualBitArray91);

            var dict92 = EnumDictionary.Create<E92, bool>();
            var expectedBitArray92 = BitArrayFactory.Create(92).GetType();
            var actualBitArray92 = dict92.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray92, actualBitArray92);

            var dict93 = EnumDictionary.Create<E93, bool>();
            var expectedBitArray93 = BitArrayFactory.Create(93).GetType();
            var actualBitArray93 = dict93.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray93, actualBitArray93);

            var dict94 = EnumDictionary.Create<E94, bool>();
            var expectedBitArray94 = BitArrayFactory.Create(94).GetType();
            var actualBitArray94 = dict94.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray94, actualBitArray94);

            var dict95 = EnumDictionary.Create<E95, bool>();
            var expectedBitArray95 = BitArrayFactory.Create(95).GetType();
            var actualBitArray95 = dict95.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray95, actualBitArray95);

            var dict96 = EnumDictionary.Create<E96, bool>();
            var expectedBitArray96 = BitArrayFactory.Create(96).GetType();
            var actualBitArray96 = dict96.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray96, actualBitArray96);

            var dict97 = EnumDictionary.Create<E97, bool>();
            var expectedBitArray97 = BitArrayFactory.Create(97).GetType();
            var actualBitArray97 = dict97.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray97, actualBitArray97);

            var dict98 = EnumDictionary.Create<E98, bool>();
            var expectedBitArray98 = BitArrayFactory.Create(98).GetType();
            var actualBitArray98 = dict98.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray98, actualBitArray98);

            var dict99 = EnumDictionary.Create<E99, bool>();
            var expectedBitArray99 = BitArrayFactory.Create(99).GetType();
            var actualBitArray99 = dict99.GetType().GetGenericArguments()[2];
            Assert.AreEqual(expectedBitArray99, actualBitArray99);

        }

        private enum E0 : int
        {
        }

        private enum E1 : int
        {
            E1_0 = 0,
        }

        private enum E2 : int
        {
            E2_0 = 0,
            E2_1 = 1,
        }

        private enum E3 : int
        {
            E3_0 = 0,
            E3_1 = 1,
            E3_2 = 2,
        }

        private enum E4 : int
        {
            E4_0 = 0,
            E4_1 = 1,
            E4_2 = 2,
            E4_3 = 3,
        }

        private enum E5 : int
        {
            E5_0 = 0,
            E5_1 = 1,
            E5_2 = 2,
            E5_3 = 3,
            E5_4 = 4,
        }

        private enum E6 : int
        {
            E6_0 = 0,
            E6_1 = 1,
            E6_2 = 2,
            E6_3 = 3,
            E6_4 = 4,
            E6_5 = 5,
        }

        private enum E7 : int
        {
            E7_0 = 0,
            E7_1 = 1,
            E7_2 = 2,
            E7_3 = 3,
            E7_4 = 4,
            E7_5 = 5,
            E7_6 = 6,
        }

        private enum E8 : int
        {
            E8_0 = 0,
            E8_1 = 1,
            E8_2 = 2,
            E8_3 = 3,
            E8_4 = 4,
            E8_5 = 5,
            E8_6 = 6,
            E8_7 = 7,
        }

        private enum E9 : int
        {
            E9_0 = 0,
            E9_1 = 1,
            E9_2 = 2,
            E9_3 = 3,
            E9_4 = 4,
            E9_5 = 5,
            E9_6 = 6,
            E9_7 = 7,
            E9_8 = 8,
        }

        private enum E10 : int
        {
            E10_0 = 0,
            E10_1 = 1,
            E10_2 = 2,
            E10_3 = 3,
            E10_4 = 4,
            E10_5 = 5,
            E10_6 = 6,
            E10_7 = 7,
            E10_8 = 8,
            E10_9 = 9,
        }

        private enum E11 : int
        {
            E11_0 = 0,
            E11_1 = 1,
            E11_2 = 2,
            E11_3 = 3,
            E11_4 = 4,
            E11_5 = 5,
            E11_6 = 6,
            E11_7 = 7,
            E11_8 = 8,
            E11_9 = 9,
            E11_10 = 10,
        }

        private enum E12 : int
        {
            E12_0 = 0,
            E12_1 = 1,
            E12_2 = 2,
            E12_3 = 3,
            E12_4 = 4,
            E12_5 = 5,
            E12_6 = 6,
            E12_7 = 7,
            E12_8 = 8,
            E12_9 = 9,
            E12_10 = 10,
            E12_11 = 11,
        }

        private enum E13 : int
        {
            E13_0 = 0,
            E13_1 = 1,
            E13_2 = 2,
            E13_3 = 3,
            E13_4 = 4,
            E13_5 = 5,
            E13_6 = 6,
            E13_7 = 7,
            E13_8 = 8,
            E13_9 = 9,
            E13_10 = 10,
            E13_11 = 11,
            E13_12 = 12,
        }

        private enum E14 : int
        {
            E14_0 = 0,
            E14_1 = 1,
            E14_2 = 2,
            E14_3 = 3,
            E14_4 = 4,
            E14_5 = 5,
            E14_6 = 6,
            E14_7 = 7,
            E14_8 = 8,
            E14_9 = 9,
            E14_10 = 10,
            E14_11 = 11,
            E14_12 = 12,
            E14_13 = 13,
        }

        private enum E15 : int
        {
            E15_0 = 0,
            E15_1 = 1,
            E15_2 = 2,
            E15_3 = 3,
            E15_4 = 4,
            E15_5 = 5,
            E15_6 = 6,
            E15_7 = 7,
            E15_8 = 8,
            E15_9 = 9,
            E15_10 = 10,
            E15_11 = 11,
            E15_12 = 12,
            E15_13 = 13,
            E15_14 = 14,
        }

        private enum E16 : int
        {
            E16_0 = 0,
            E16_1 = 1,
            E16_2 = 2,
            E16_3 = 3,
            E16_4 = 4,
            E16_5 = 5,
            E16_6 = 6,
            E16_7 = 7,
            E16_8 = 8,
            E16_9 = 9,
            E16_10 = 10,
            E16_11 = 11,
            E16_12 = 12,
            E16_13 = 13,
            E16_14 = 14,
            E16_15 = 15,
        }

        private enum E17 : int
        {
            E17_0 = 0,
            E17_1 = 1,
            E17_2 = 2,
            E17_3 = 3,
            E17_4 = 4,
            E17_5 = 5,
            E17_6 = 6,
            E17_7 = 7,
            E17_8 = 8,
            E17_9 = 9,
            E17_10 = 10,
            E17_11 = 11,
            E17_12 = 12,
            E17_13 = 13,
            E17_14 = 14,
            E17_15 = 15,
            E17_16 = 16,
        }

        private enum E18 : int
        {
            E18_0 = 0,
            E18_1 = 1,
            E18_2 = 2,
            E18_3 = 3,
            E18_4 = 4,
            E18_5 = 5,
            E18_6 = 6,
            E18_7 = 7,
            E18_8 = 8,
            E18_9 = 9,
            E18_10 = 10,
            E18_11 = 11,
            E18_12 = 12,
            E18_13 = 13,
            E18_14 = 14,
            E18_15 = 15,
            E18_16 = 16,
            E18_17 = 17,
        }

        private enum E19 : int
        {
            E19_0 = 0,
            E19_1 = 1,
            E19_2 = 2,
            E19_3 = 3,
            E19_4 = 4,
            E19_5 = 5,
            E19_6 = 6,
            E19_7 = 7,
            E19_8 = 8,
            E19_9 = 9,
            E19_10 = 10,
            E19_11 = 11,
            E19_12 = 12,
            E19_13 = 13,
            E19_14 = 14,
            E19_15 = 15,
            E19_16 = 16,
            E19_17 = 17,
            E19_18 = 18,
        }

        private enum E20 : int
        {
            E20_0 = 0,
            E20_1 = 1,
            E20_2 = 2,
            E20_3 = 3,
            E20_4 = 4,
            E20_5 = 5,
            E20_6 = 6,
            E20_7 = 7,
            E20_8 = 8,
            E20_9 = 9,
            E20_10 = 10,
            E20_11 = 11,
            E20_12 = 12,
            E20_13 = 13,
            E20_14 = 14,
            E20_15 = 15,
            E20_16 = 16,
            E20_17 = 17,
            E20_18 = 18,
            E20_19 = 19,
        }

        private enum E21 : int
        {
            E21_0 = 0,
            E21_1 = 1,
            E21_2 = 2,
            E21_3 = 3,
            E21_4 = 4,
            E21_5 = 5,
            E21_6 = 6,
            E21_7 = 7,
            E21_8 = 8,
            E21_9 = 9,
            E21_10 = 10,
            E21_11 = 11,
            E21_12 = 12,
            E21_13 = 13,
            E21_14 = 14,
            E21_15 = 15,
            E21_16 = 16,
            E21_17 = 17,
            E21_18 = 18,
            E21_19 = 19,
            E21_20 = 20,
        }

        private enum E22 : int
        {
            E22_0 = 0,
            E22_1 = 1,
            E22_2 = 2,
            E22_3 = 3,
            E22_4 = 4,
            E22_5 = 5,
            E22_6 = 6,
            E22_7 = 7,
            E22_8 = 8,
            E22_9 = 9,
            E22_10 = 10,
            E22_11 = 11,
            E22_12 = 12,
            E22_13 = 13,
            E22_14 = 14,
            E22_15 = 15,
            E22_16 = 16,
            E22_17 = 17,
            E22_18 = 18,
            E22_19 = 19,
            E22_20 = 20,
            E22_21 = 21,
        }

        private enum E23 : int
        {
            E23_0 = 0,
            E23_1 = 1,
            E23_2 = 2,
            E23_3 = 3,
            E23_4 = 4,
            E23_5 = 5,
            E23_6 = 6,
            E23_7 = 7,
            E23_8 = 8,
            E23_9 = 9,
            E23_10 = 10,
            E23_11 = 11,
            E23_12 = 12,
            E23_13 = 13,
            E23_14 = 14,
            E23_15 = 15,
            E23_16 = 16,
            E23_17 = 17,
            E23_18 = 18,
            E23_19 = 19,
            E23_20 = 20,
            E23_21 = 21,
            E23_22 = 22,
        }

        private enum E24 : int
        {
            E24_0 = 0,
            E24_1 = 1,
            E24_2 = 2,
            E24_3 = 3,
            E24_4 = 4,
            E24_5 = 5,
            E24_6 = 6,
            E24_7 = 7,
            E24_8 = 8,
            E24_9 = 9,
            E24_10 = 10,
            E24_11 = 11,
            E24_12 = 12,
            E24_13 = 13,
            E24_14 = 14,
            E24_15 = 15,
            E24_16 = 16,
            E24_17 = 17,
            E24_18 = 18,
            E24_19 = 19,
            E24_20 = 20,
            E24_21 = 21,
            E24_22 = 22,
            E24_23 = 23,
        }

        private enum E25 : int
        {
            E25_0 = 0,
            E25_1 = 1,
            E25_2 = 2,
            E25_3 = 3,
            E25_4 = 4,
            E25_5 = 5,
            E25_6 = 6,
            E25_7 = 7,
            E25_8 = 8,
            E25_9 = 9,
            E25_10 = 10,
            E25_11 = 11,
            E25_12 = 12,
            E25_13 = 13,
            E25_14 = 14,
            E25_15 = 15,
            E25_16 = 16,
            E25_17 = 17,
            E25_18 = 18,
            E25_19 = 19,
            E25_20 = 20,
            E25_21 = 21,
            E25_22 = 22,
            E25_23 = 23,
            E25_24 = 24,
        }

        private enum E26 : int
        {
            E26_0 = 0,
            E26_1 = 1,
            E26_2 = 2,
            E26_3 = 3,
            E26_4 = 4,
            E26_5 = 5,
            E26_6 = 6,
            E26_7 = 7,
            E26_8 = 8,
            E26_9 = 9,
            E26_10 = 10,
            E26_11 = 11,
            E26_12 = 12,
            E26_13 = 13,
            E26_14 = 14,
            E26_15 = 15,
            E26_16 = 16,
            E26_17 = 17,
            E26_18 = 18,
            E26_19 = 19,
            E26_20 = 20,
            E26_21 = 21,
            E26_22 = 22,
            E26_23 = 23,
            E26_24 = 24,
            E26_25 = 25,
        }

        private enum E27 : int
        {
            E27_0 = 0,
            E27_1 = 1,
            E27_2 = 2,
            E27_3 = 3,
            E27_4 = 4,
            E27_5 = 5,
            E27_6 = 6,
            E27_7 = 7,
            E27_8 = 8,
            E27_9 = 9,
            E27_10 = 10,
            E27_11 = 11,
            E27_12 = 12,
            E27_13 = 13,
            E27_14 = 14,
            E27_15 = 15,
            E27_16 = 16,
            E27_17 = 17,
            E27_18 = 18,
            E27_19 = 19,
            E27_20 = 20,
            E27_21 = 21,
            E27_22 = 22,
            E27_23 = 23,
            E27_24 = 24,
            E27_25 = 25,
            E27_26 = 26,
        }

        private enum E28 : int
        {
            E28_0 = 0,
            E28_1 = 1,
            E28_2 = 2,
            E28_3 = 3,
            E28_4 = 4,
            E28_5 = 5,
            E28_6 = 6,
            E28_7 = 7,
            E28_8 = 8,
            E28_9 = 9,
            E28_10 = 10,
            E28_11 = 11,
            E28_12 = 12,
            E28_13 = 13,
            E28_14 = 14,
            E28_15 = 15,
            E28_16 = 16,
            E28_17 = 17,
            E28_18 = 18,
            E28_19 = 19,
            E28_20 = 20,
            E28_21 = 21,
            E28_22 = 22,
            E28_23 = 23,
            E28_24 = 24,
            E28_25 = 25,
            E28_26 = 26,
            E28_27 = 27,
        }

        private enum E29 : int
        {
            E29_0 = 0,
            E29_1 = 1,
            E29_2 = 2,
            E29_3 = 3,
            E29_4 = 4,
            E29_5 = 5,
            E29_6 = 6,
            E29_7 = 7,
            E29_8 = 8,
            E29_9 = 9,
            E29_10 = 10,
            E29_11 = 11,
            E29_12 = 12,
            E29_13 = 13,
            E29_14 = 14,
            E29_15 = 15,
            E29_16 = 16,
            E29_17 = 17,
            E29_18 = 18,
            E29_19 = 19,
            E29_20 = 20,
            E29_21 = 21,
            E29_22 = 22,
            E29_23 = 23,
            E29_24 = 24,
            E29_25 = 25,
            E29_26 = 26,
            E29_27 = 27,
            E29_28 = 28,
        }

        private enum E30 : int
        {
            E30_0 = 0,
            E30_1 = 1,
            E30_2 = 2,
            E30_3 = 3,
            E30_4 = 4,
            E30_5 = 5,
            E30_6 = 6,
            E30_7 = 7,
            E30_8 = 8,
            E30_9 = 9,
            E30_10 = 10,
            E30_11 = 11,
            E30_12 = 12,
            E30_13 = 13,
            E30_14 = 14,
            E30_15 = 15,
            E30_16 = 16,
            E30_17 = 17,
            E30_18 = 18,
            E30_19 = 19,
            E30_20 = 20,
            E30_21 = 21,
            E30_22 = 22,
            E30_23 = 23,
            E30_24 = 24,
            E30_25 = 25,
            E30_26 = 26,
            E30_27 = 27,
            E30_28 = 28,
            E30_29 = 29,
        }

        private enum E31 : int
        {
            E31_0 = 0,
            E31_1 = 1,
            E31_2 = 2,
            E31_3 = 3,
            E31_4 = 4,
            E31_5 = 5,
            E31_6 = 6,
            E31_7 = 7,
            E31_8 = 8,
            E31_9 = 9,
            E31_10 = 10,
            E31_11 = 11,
            E31_12 = 12,
            E31_13 = 13,
            E31_14 = 14,
            E31_15 = 15,
            E31_16 = 16,
            E31_17 = 17,
            E31_18 = 18,
            E31_19 = 19,
            E31_20 = 20,
            E31_21 = 21,
            E31_22 = 22,
            E31_23 = 23,
            E31_24 = 24,
            E31_25 = 25,
            E31_26 = 26,
            E31_27 = 27,
            E31_28 = 28,
            E31_29 = 29,
            E31_30 = 30,
        }

        private enum E32 : int
        {
            E32_0 = 0,
            E32_1 = 1,
            E32_2 = 2,
            E32_3 = 3,
            E32_4 = 4,
            E32_5 = 5,
            E32_6 = 6,
            E32_7 = 7,
            E32_8 = 8,
            E32_9 = 9,
            E32_10 = 10,
            E32_11 = 11,
            E32_12 = 12,
            E32_13 = 13,
            E32_14 = 14,
            E32_15 = 15,
            E32_16 = 16,
            E32_17 = 17,
            E32_18 = 18,
            E32_19 = 19,
            E32_20 = 20,
            E32_21 = 21,
            E32_22 = 22,
            E32_23 = 23,
            E32_24 = 24,
            E32_25 = 25,
            E32_26 = 26,
            E32_27 = 27,
            E32_28 = 28,
            E32_29 = 29,
            E32_30 = 30,
            E32_31 = 31,
        }

        private enum E33 : int
        {
            E33_0 = 0,
            E33_1 = 1,
            E33_2 = 2,
            E33_3 = 3,
            E33_4 = 4,
            E33_5 = 5,
            E33_6 = 6,
            E33_7 = 7,
            E33_8 = 8,
            E33_9 = 9,
            E33_10 = 10,
            E33_11 = 11,
            E33_12 = 12,
            E33_13 = 13,
            E33_14 = 14,
            E33_15 = 15,
            E33_16 = 16,
            E33_17 = 17,
            E33_18 = 18,
            E33_19 = 19,
            E33_20 = 20,
            E33_21 = 21,
            E33_22 = 22,
            E33_23 = 23,
            E33_24 = 24,
            E33_25 = 25,
            E33_26 = 26,
            E33_27 = 27,
            E33_28 = 28,
            E33_29 = 29,
            E33_30 = 30,
            E33_31 = 31,
            E33_32 = 32,
        }

        private enum E34 : int
        {
            E34_0 = 0,
            E34_1 = 1,
            E34_2 = 2,
            E34_3 = 3,
            E34_4 = 4,
            E34_5 = 5,
            E34_6 = 6,
            E34_7 = 7,
            E34_8 = 8,
            E34_9 = 9,
            E34_10 = 10,
            E34_11 = 11,
            E34_12 = 12,
            E34_13 = 13,
            E34_14 = 14,
            E34_15 = 15,
            E34_16 = 16,
            E34_17 = 17,
            E34_18 = 18,
            E34_19 = 19,
            E34_20 = 20,
            E34_21 = 21,
            E34_22 = 22,
            E34_23 = 23,
            E34_24 = 24,
            E34_25 = 25,
            E34_26 = 26,
            E34_27 = 27,
            E34_28 = 28,
            E34_29 = 29,
            E34_30 = 30,
            E34_31 = 31,
            E34_32 = 32,
            E34_33 = 33,
        }

        private enum E35 : int
        {
            E35_0 = 0,
            E35_1 = 1,
            E35_2 = 2,
            E35_3 = 3,
            E35_4 = 4,
            E35_5 = 5,
            E35_6 = 6,
            E35_7 = 7,
            E35_8 = 8,
            E35_9 = 9,
            E35_10 = 10,
            E35_11 = 11,
            E35_12 = 12,
            E35_13 = 13,
            E35_14 = 14,
            E35_15 = 15,
            E35_16 = 16,
            E35_17 = 17,
            E35_18 = 18,
            E35_19 = 19,
            E35_20 = 20,
            E35_21 = 21,
            E35_22 = 22,
            E35_23 = 23,
            E35_24 = 24,
            E35_25 = 25,
            E35_26 = 26,
            E35_27 = 27,
            E35_28 = 28,
            E35_29 = 29,
            E35_30 = 30,
            E35_31 = 31,
            E35_32 = 32,
            E35_33 = 33,
            E35_34 = 34,
        }

        private enum E36 : int
        {
            E36_0 = 0,
            E36_1 = 1,
            E36_2 = 2,
            E36_3 = 3,
            E36_4 = 4,
            E36_5 = 5,
            E36_6 = 6,
            E36_7 = 7,
            E36_8 = 8,
            E36_9 = 9,
            E36_10 = 10,
            E36_11 = 11,
            E36_12 = 12,
            E36_13 = 13,
            E36_14 = 14,
            E36_15 = 15,
            E36_16 = 16,
            E36_17 = 17,
            E36_18 = 18,
            E36_19 = 19,
            E36_20 = 20,
            E36_21 = 21,
            E36_22 = 22,
            E36_23 = 23,
            E36_24 = 24,
            E36_25 = 25,
            E36_26 = 26,
            E36_27 = 27,
            E36_28 = 28,
            E36_29 = 29,
            E36_30 = 30,
            E36_31 = 31,
            E36_32 = 32,
            E36_33 = 33,
            E36_34 = 34,
            E36_35 = 35,
        }

        private enum E37 : int
        {
            E37_0 = 0,
            E37_1 = 1,
            E37_2 = 2,
            E37_3 = 3,
            E37_4 = 4,
            E37_5 = 5,
            E37_6 = 6,
            E37_7 = 7,
            E37_8 = 8,
            E37_9 = 9,
            E37_10 = 10,
            E37_11 = 11,
            E37_12 = 12,
            E37_13 = 13,
            E37_14 = 14,
            E37_15 = 15,
            E37_16 = 16,
            E37_17 = 17,
            E37_18 = 18,
            E37_19 = 19,
            E37_20 = 20,
            E37_21 = 21,
            E37_22 = 22,
            E37_23 = 23,
            E37_24 = 24,
            E37_25 = 25,
            E37_26 = 26,
            E37_27 = 27,
            E37_28 = 28,
            E37_29 = 29,
            E37_30 = 30,
            E37_31 = 31,
            E37_32 = 32,
            E37_33 = 33,
            E37_34 = 34,
            E37_35 = 35,
            E37_36 = 36,
        }

        private enum E38 : int
        {
            E38_0 = 0,
            E38_1 = 1,
            E38_2 = 2,
            E38_3 = 3,
            E38_4 = 4,
            E38_5 = 5,
            E38_6 = 6,
            E38_7 = 7,
            E38_8 = 8,
            E38_9 = 9,
            E38_10 = 10,
            E38_11 = 11,
            E38_12 = 12,
            E38_13 = 13,
            E38_14 = 14,
            E38_15 = 15,
            E38_16 = 16,
            E38_17 = 17,
            E38_18 = 18,
            E38_19 = 19,
            E38_20 = 20,
            E38_21 = 21,
            E38_22 = 22,
            E38_23 = 23,
            E38_24 = 24,
            E38_25 = 25,
            E38_26 = 26,
            E38_27 = 27,
            E38_28 = 28,
            E38_29 = 29,
            E38_30 = 30,
            E38_31 = 31,
            E38_32 = 32,
            E38_33 = 33,
            E38_34 = 34,
            E38_35 = 35,
            E38_36 = 36,
            E38_37 = 37,
        }

        private enum E39 : int
        {
            E39_0 = 0,
            E39_1 = 1,
            E39_2 = 2,
            E39_3 = 3,
            E39_4 = 4,
            E39_5 = 5,
            E39_6 = 6,
            E39_7 = 7,
            E39_8 = 8,
            E39_9 = 9,
            E39_10 = 10,
            E39_11 = 11,
            E39_12 = 12,
            E39_13 = 13,
            E39_14 = 14,
            E39_15 = 15,
            E39_16 = 16,
            E39_17 = 17,
            E39_18 = 18,
            E39_19 = 19,
            E39_20 = 20,
            E39_21 = 21,
            E39_22 = 22,
            E39_23 = 23,
            E39_24 = 24,
            E39_25 = 25,
            E39_26 = 26,
            E39_27 = 27,
            E39_28 = 28,
            E39_29 = 29,
            E39_30 = 30,
            E39_31 = 31,
            E39_32 = 32,
            E39_33 = 33,
            E39_34 = 34,
            E39_35 = 35,
            E39_36 = 36,
            E39_37 = 37,
            E39_38 = 38,
        }

        private enum E40 : int
        {
            E40_0 = 0,
            E40_1 = 1,
            E40_2 = 2,
            E40_3 = 3,
            E40_4 = 4,
            E40_5 = 5,
            E40_6 = 6,
            E40_7 = 7,
            E40_8 = 8,
            E40_9 = 9,
            E40_10 = 10,
            E40_11 = 11,
            E40_12 = 12,
            E40_13 = 13,
            E40_14 = 14,
            E40_15 = 15,
            E40_16 = 16,
            E40_17 = 17,
            E40_18 = 18,
            E40_19 = 19,
            E40_20 = 20,
            E40_21 = 21,
            E40_22 = 22,
            E40_23 = 23,
            E40_24 = 24,
            E40_25 = 25,
            E40_26 = 26,
            E40_27 = 27,
            E40_28 = 28,
            E40_29 = 29,
            E40_30 = 30,
            E40_31 = 31,
            E40_32 = 32,
            E40_33 = 33,
            E40_34 = 34,
            E40_35 = 35,
            E40_36 = 36,
            E40_37 = 37,
            E40_38 = 38,
            E40_39 = 39,
        }

        private enum E41 : int
        {
            E41_0 = 0,
            E41_1 = 1,
            E41_2 = 2,
            E41_3 = 3,
            E41_4 = 4,
            E41_5 = 5,
            E41_6 = 6,
            E41_7 = 7,
            E41_8 = 8,
            E41_9 = 9,
            E41_10 = 10,
            E41_11 = 11,
            E41_12 = 12,
            E41_13 = 13,
            E41_14 = 14,
            E41_15 = 15,
            E41_16 = 16,
            E41_17 = 17,
            E41_18 = 18,
            E41_19 = 19,
            E41_20 = 20,
            E41_21 = 21,
            E41_22 = 22,
            E41_23 = 23,
            E41_24 = 24,
            E41_25 = 25,
            E41_26 = 26,
            E41_27 = 27,
            E41_28 = 28,
            E41_29 = 29,
            E41_30 = 30,
            E41_31 = 31,
            E41_32 = 32,
            E41_33 = 33,
            E41_34 = 34,
            E41_35 = 35,
            E41_36 = 36,
            E41_37 = 37,
            E41_38 = 38,
            E41_39 = 39,
            E41_40 = 40,
        }

        private enum E42 : int
        {
            E42_0 = 0,
            E42_1 = 1,
            E42_2 = 2,
            E42_3 = 3,
            E42_4 = 4,
            E42_5 = 5,
            E42_6 = 6,
            E42_7 = 7,
            E42_8 = 8,
            E42_9 = 9,
            E42_10 = 10,
            E42_11 = 11,
            E42_12 = 12,
            E42_13 = 13,
            E42_14 = 14,
            E42_15 = 15,
            E42_16 = 16,
            E42_17 = 17,
            E42_18 = 18,
            E42_19 = 19,
            E42_20 = 20,
            E42_21 = 21,
            E42_22 = 22,
            E42_23 = 23,
            E42_24 = 24,
            E42_25 = 25,
            E42_26 = 26,
            E42_27 = 27,
            E42_28 = 28,
            E42_29 = 29,
            E42_30 = 30,
            E42_31 = 31,
            E42_32 = 32,
            E42_33 = 33,
            E42_34 = 34,
            E42_35 = 35,
            E42_36 = 36,
            E42_37 = 37,
            E42_38 = 38,
            E42_39 = 39,
            E42_40 = 40,
            E42_41 = 41,
        }

        private enum E43 : int
        {
            E43_0 = 0,
            E43_1 = 1,
            E43_2 = 2,
            E43_3 = 3,
            E43_4 = 4,
            E43_5 = 5,
            E43_6 = 6,
            E43_7 = 7,
            E43_8 = 8,
            E43_9 = 9,
            E43_10 = 10,
            E43_11 = 11,
            E43_12 = 12,
            E43_13 = 13,
            E43_14 = 14,
            E43_15 = 15,
            E43_16 = 16,
            E43_17 = 17,
            E43_18 = 18,
            E43_19 = 19,
            E43_20 = 20,
            E43_21 = 21,
            E43_22 = 22,
            E43_23 = 23,
            E43_24 = 24,
            E43_25 = 25,
            E43_26 = 26,
            E43_27 = 27,
            E43_28 = 28,
            E43_29 = 29,
            E43_30 = 30,
            E43_31 = 31,
            E43_32 = 32,
            E43_33 = 33,
            E43_34 = 34,
            E43_35 = 35,
            E43_36 = 36,
            E43_37 = 37,
            E43_38 = 38,
            E43_39 = 39,
            E43_40 = 40,
            E43_41 = 41,
            E43_42 = 42,
        }

        private enum E44 : int
        {
            E44_0 = 0,
            E44_1 = 1,
            E44_2 = 2,
            E44_3 = 3,
            E44_4 = 4,
            E44_5 = 5,
            E44_6 = 6,
            E44_7 = 7,
            E44_8 = 8,
            E44_9 = 9,
            E44_10 = 10,
            E44_11 = 11,
            E44_12 = 12,
            E44_13 = 13,
            E44_14 = 14,
            E44_15 = 15,
            E44_16 = 16,
            E44_17 = 17,
            E44_18 = 18,
            E44_19 = 19,
            E44_20 = 20,
            E44_21 = 21,
            E44_22 = 22,
            E44_23 = 23,
            E44_24 = 24,
            E44_25 = 25,
            E44_26 = 26,
            E44_27 = 27,
            E44_28 = 28,
            E44_29 = 29,
            E44_30 = 30,
            E44_31 = 31,
            E44_32 = 32,
            E44_33 = 33,
            E44_34 = 34,
            E44_35 = 35,
            E44_36 = 36,
            E44_37 = 37,
            E44_38 = 38,
            E44_39 = 39,
            E44_40 = 40,
            E44_41 = 41,
            E44_42 = 42,
            E44_43 = 43,
        }

        private enum E45 : int
        {
            E45_0 = 0,
            E45_1 = 1,
            E45_2 = 2,
            E45_3 = 3,
            E45_4 = 4,
            E45_5 = 5,
            E45_6 = 6,
            E45_7 = 7,
            E45_8 = 8,
            E45_9 = 9,
            E45_10 = 10,
            E45_11 = 11,
            E45_12 = 12,
            E45_13 = 13,
            E45_14 = 14,
            E45_15 = 15,
            E45_16 = 16,
            E45_17 = 17,
            E45_18 = 18,
            E45_19 = 19,
            E45_20 = 20,
            E45_21 = 21,
            E45_22 = 22,
            E45_23 = 23,
            E45_24 = 24,
            E45_25 = 25,
            E45_26 = 26,
            E45_27 = 27,
            E45_28 = 28,
            E45_29 = 29,
            E45_30 = 30,
            E45_31 = 31,
            E45_32 = 32,
            E45_33 = 33,
            E45_34 = 34,
            E45_35 = 35,
            E45_36 = 36,
            E45_37 = 37,
            E45_38 = 38,
            E45_39 = 39,
            E45_40 = 40,
            E45_41 = 41,
            E45_42 = 42,
            E45_43 = 43,
            E45_44 = 44,
        }

        private enum E46 : int
        {
            E46_0 = 0,
            E46_1 = 1,
            E46_2 = 2,
            E46_3 = 3,
            E46_4 = 4,
            E46_5 = 5,
            E46_6 = 6,
            E46_7 = 7,
            E46_8 = 8,
            E46_9 = 9,
            E46_10 = 10,
            E46_11 = 11,
            E46_12 = 12,
            E46_13 = 13,
            E46_14 = 14,
            E46_15 = 15,
            E46_16 = 16,
            E46_17 = 17,
            E46_18 = 18,
            E46_19 = 19,
            E46_20 = 20,
            E46_21 = 21,
            E46_22 = 22,
            E46_23 = 23,
            E46_24 = 24,
            E46_25 = 25,
            E46_26 = 26,
            E46_27 = 27,
            E46_28 = 28,
            E46_29 = 29,
            E46_30 = 30,
            E46_31 = 31,
            E46_32 = 32,
            E46_33 = 33,
            E46_34 = 34,
            E46_35 = 35,
            E46_36 = 36,
            E46_37 = 37,
            E46_38 = 38,
            E46_39 = 39,
            E46_40 = 40,
            E46_41 = 41,
            E46_42 = 42,
            E46_43 = 43,
            E46_44 = 44,
            E46_45 = 45,
        }

        private enum E47 : int
        {
            E47_0 = 0,
            E47_1 = 1,
            E47_2 = 2,
            E47_3 = 3,
            E47_4 = 4,
            E47_5 = 5,
            E47_6 = 6,
            E47_7 = 7,
            E47_8 = 8,
            E47_9 = 9,
            E47_10 = 10,
            E47_11 = 11,
            E47_12 = 12,
            E47_13 = 13,
            E47_14 = 14,
            E47_15 = 15,
            E47_16 = 16,
            E47_17 = 17,
            E47_18 = 18,
            E47_19 = 19,
            E47_20 = 20,
            E47_21 = 21,
            E47_22 = 22,
            E47_23 = 23,
            E47_24 = 24,
            E47_25 = 25,
            E47_26 = 26,
            E47_27 = 27,
            E47_28 = 28,
            E47_29 = 29,
            E47_30 = 30,
            E47_31 = 31,
            E47_32 = 32,
            E47_33 = 33,
            E47_34 = 34,
            E47_35 = 35,
            E47_36 = 36,
            E47_37 = 37,
            E47_38 = 38,
            E47_39 = 39,
            E47_40 = 40,
            E47_41 = 41,
            E47_42 = 42,
            E47_43 = 43,
            E47_44 = 44,
            E47_45 = 45,
            E47_46 = 46,
        }

        private enum E48 : int
        {
            E48_0 = 0,
            E48_1 = 1,
            E48_2 = 2,
            E48_3 = 3,
            E48_4 = 4,
            E48_5 = 5,
            E48_6 = 6,
            E48_7 = 7,
            E48_8 = 8,
            E48_9 = 9,
            E48_10 = 10,
            E48_11 = 11,
            E48_12 = 12,
            E48_13 = 13,
            E48_14 = 14,
            E48_15 = 15,
            E48_16 = 16,
            E48_17 = 17,
            E48_18 = 18,
            E48_19 = 19,
            E48_20 = 20,
            E48_21 = 21,
            E48_22 = 22,
            E48_23 = 23,
            E48_24 = 24,
            E48_25 = 25,
            E48_26 = 26,
            E48_27 = 27,
            E48_28 = 28,
            E48_29 = 29,
            E48_30 = 30,
            E48_31 = 31,
            E48_32 = 32,
            E48_33 = 33,
            E48_34 = 34,
            E48_35 = 35,
            E48_36 = 36,
            E48_37 = 37,
            E48_38 = 38,
            E48_39 = 39,
            E48_40 = 40,
            E48_41 = 41,
            E48_42 = 42,
            E48_43 = 43,
            E48_44 = 44,
            E48_45 = 45,
            E48_46 = 46,
            E48_47 = 47,
        }

        private enum E49 : int
        {
            E49_0 = 0,
            E49_1 = 1,
            E49_2 = 2,
            E49_3 = 3,
            E49_4 = 4,
            E49_5 = 5,
            E49_6 = 6,
            E49_7 = 7,
            E49_8 = 8,
            E49_9 = 9,
            E49_10 = 10,
            E49_11 = 11,
            E49_12 = 12,
            E49_13 = 13,
            E49_14 = 14,
            E49_15 = 15,
            E49_16 = 16,
            E49_17 = 17,
            E49_18 = 18,
            E49_19 = 19,
            E49_20 = 20,
            E49_21 = 21,
            E49_22 = 22,
            E49_23 = 23,
            E49_24 = 24,
            E49_25 = 25,
            E49_26 = 26,
            E49_27 = 27,
            E49_28 = 28,
            E49_29 = 29,
            E49_30 = 30,
            E49_31 = 31,
            E49_32 = 32,
            E49_33 = 33,
            E49_34 = 34,
            E49_35 = 35,
            E49_36 = 36,
            E49_37 = 37,
            E49_38 = 38,
            E49_39 = 39,
            E49_40 = 40,
            E49_41 = 41,
            E49_42 = 42,
            E49_43 = 43,
            E49_44 = 44,
            E49_45 = 45,
            E49_46 = 46,
            E49_47 = 47,
            E49_48 = 48,
        }

        private enum E50 : int
        {
            E50_0 = 0,
            E50_1 = 1,
            E50_2 = 2,
            E50_3 = 3,
            E50_4 = 4,
            E50_5 = 5,
            E50_6 = 6,
            E50_7 = 7,
            E50_8 = 8,
            E50_9 = 9,
            E50_10 = 10,
            E50_11 = 11,
            E50_12 = 12,
            E50_13 = 13,
            E50_14 = 14,
            E50_15 = 15,
            E50_16 = 16,
            E50_17 = 17,
            E50_18 = 18,
            E50_19 = 19,
            E50_20 = 20,
            E50_21 = 21,
            E50_22 = 22,
            E50_23 = 23,
            E50_24 = 24,
            E50_25 = 25,
            E50_26 = 26,
            E50_27 = 27,
            E50_28 = 28,
            E50_29 = 29,
            E50_30 = 30,
            E50_31 = 31,
            E50_32 = 32,
            E50_33 = 33,
            E50_34 = 34,
            E50_35 = 35,
            E50_36 = 36,
            E50_37 = 37,
            E50_38 = 38,
            E50_39 = 39,
            E50_40 = 40,
            E50_41 = 41,
            E50_42 = 42,
            E50_43 = 43,
            E50_44 = 44,
            E50_45 = 45,
            E50_46 = 46,
            E50_47 = 47,
            E50_48 = 48,
            E50_49 = 49,
        }

        private enum E51 : int
        {
            E51_0 = 0,
            E51_1 = 1,
            E51_2 = 2,
            E51_3 = 3,
            E51_4 = 4,
            E51_5 = 5,
            E51_6 = 6,
            E51_7 = 7,
            E51_8 = 8,
            E51_9 = 9,
            E51_10 = 10,
            E51_11 = 11,
            E51_12 = 12,
            E51_13 = 13,
            E51_14 = 14,
            E51_15 = 15,
            E51_16 = 16,
            E51_17 = 17,
            E51_18 = 18,
            E51_19 = 19,
            E51_20 = 20,
            E51_21 = 21,
            E51_22 = 22,
            E51_23 = 23,
            E51_24 = 24,
            E51_25 = 25,
            E51_26 = 26,
            E51_27 = 27,
            E51_28 = 28,
            E51_29 = 29,
            E51_30 = 30,
            E51_31 = 31,
            E51_32 = 32,
            E51_33 = 33,
            E51_34 = 34,
            E51_35 = 35,
            E51_36 = 36,
            E51_37 = 37,
            E51_38 = 38,
            E51_39 = 39,
            E51_40 = 40,
            E51_41 = 41,
            E51_42 = 42,
            E51_43 = 43,
            E51_44 = 44,
            E51_45 = 45,
            E51_46 = 46,
            E51_47 = 47,
            E51_48 = 48,
            E51_49 = 49,
            E51_50 = 50,
        }

        private enum E52 : int
        {
            E52_0 = 0,
            E52_1 = 1,
            E52_2 = 2,
            E52_3 = 3,
            E52_4 = 4,
            E52_5 = 5,
            E52_6 = 6,
            E52_7 = 7,
            E52_8 = 8,
            E52_9 = 9,
            E52_10 = 10,
            E52_11 = 11,
            E52_12 = 12,
            E52_13 = 13,
            E52_14 = 14,
            E52_15 = 15,
            E52_16 = 16,
            E52_17 = 17,
            E52_18 = 18,
            E52_19 = 19,
            E52_20 = 20,
            E52_21 = 21,
            E52_22 = 22,
            E52_23 = 23,
            E52_24 = 24,
            E52_25 = 25,
            E52_26 = 26,
            E52_27 = 27,
            E52_28 = 28,
            E52_29 = 29,
            E52_30 = 30,
            E52_31 = 31,
            E52_32 = 32,
            E52_33 = 33,
            E52_34 = 34,
            E52_35 = 35,
            E52_36 = 36,
            E52_37 = 37,
            E52_38 = 38,
            E52_39 = 39,
            E52_40 = 40,
            E52_41 = 41,
            E52_42 = 42,
            E52_43 = 43,
            E52_44 = 44,
            E52_45 = 45,
            E52_46 = 46,
            E52_47 = 47,
            E52_48 = 48,
            E52_49 = 49,
            E52_50 = 50,
            E52_51 = 51,
        }

        private enum E53 : int
        {
            E53_0 = 0,
            E53_1 = 1,
            E53_2 = 2,
            E53_3 = 3,
            E53_4 = 4,
            E53_5 = 5,
            E53_6 = 6,
            E53_7 = 7,
            E53_8 = 8,
            E53_9 = 9,
            E53_10 = 10,
            E53_11 = 11,
            E53_12 = 12,
            E53_13 = 13,
            E53_14 = 14,
            E53_15 = 15,
            E53_16 = 16,
            E53_17 = 17,
            E53_18 = 18,
            E53_19 = 19,
            E53_20 = 20,
            E53_21 = 21,
            E53_22 = 22,
            E53_23 = 23,
            E53_24 = 24,
            E53_25 = 25,
            E53_26 = 26,
            E53_27 = 27,
            E53_28 = 28,
            E53_29 = 29,
            E53_30 = 30,
            E53_31 = 31,
            E53_32 = 32,
            E53_33 = 33,
            E53_34 = 34,
            E53_35 = 35,
            E53_36 = 36,
            E53_37 = 37,
            E53_38 = 38,
            E53_39 = 39,
            E53_40 = 40,
            E53_41 = 41,
            E53_42 = 42,
            E53_43 = 43,
            E53_44 = 44,
            E53_45 = 45,
            E53_46 = 46,
            E53_47 = 47,
            E53_48 = 48,
            E53_49 = 49,
            E53_50 = 50,
            E53_51 = 51,
            E53_52 = 52,
        }

        private enum E54 : int
        {
            E54_0 = 0,
            E54_1 = 1,
            E54_2 = 2,
            E54_3 = 3,
            E54_4 = 4,
            E54_5 = 5,
            E54_6 = 6,
            E54_7 = 7,
            E54_8 = 8,
            E54_9 = 9,
            E54_10 = 10,
            E54_11 = 11,
            E54_12 = 12,
            E54_13 = 13,
            E54_14 = 14,
            E54_15 = 15,
            E54_16 = 16,
            E54_17 = 17,
            E54_18 = 18,
            E54_19 = 19,
            E54_20 = 20,
            E54_21 = 21,
            E54_22 = 22,
            E54_23 = 23,
            E54_24 = 24,
            E54_25 = 25,
            E54_26 = 26,
            E54_27 = 27,
            E54_28 = 28,
            E54_29 = 29,
            E54_30 = 30,
            E54_31 = 31,
            E54_32 = 32,
            E54_33 = 33,
            E54_34 = 34,
            E54_35 = 35,
            E54_36 = 36,
            E54_37 = 37,
            E54_38 = 38,
            E54_39 = 39,
            E54_40 = 40,
            E54_41 = 41,
            E54_42 = 42,
            E54_43 = 43,
            E54_44 = 44,
            E54_45 = 45,
            E54_46 = 46,
            E54_47 = 47,
            E54_48 = 48,
            E54_49 = 49,
            E54_50 = 50,
            E54_51 = 51,
            E54_52 = 52,
            E54_53 = 53,
        }

        private enum E55 : int
        {
            E55_0 = 0,
            E55_1 = 1,
            E55_2 = 2,
            E55_3 = 3,
            E55_4 = 4,
            E55_5 = 5,
            E55_6 = 6,
            E55_7 = 7,
            E55_8 = 8,
            E55_9 = 9,
            E55_10 = 10,
            E55_11 = 11,
            E55_12 = 12,
            E55_13 = 13,
            E55_14 = 14,
            E55_15 = 15,
            E55_16 = 16,
            E55_17 = 17,
            E55_18 = 18,
            E55_19 = 19,
            E55_20 = 20,
            E55_21 = 21,
            E55_22 = 22,
            E55_23 = 23,
            E55_24 = 24,
            E55_25 = 25,
            E55_26 = 26,
            E55_27 = 27,
            E55_28 = 28,
            E55_29 = 29,
            E55_30 = 30,
            E55_31 = 31,
            E55_32 = 32,
            E55_33 = 33,
            E55_34 = 34,
            E55_35 = 35,
            E55_36 = 36,
            E55_37 = 37,
            E55_38 = 38,
            E55_39 = 39,
            E55_40 = 40,
            E55_41 = 41,
            E55_42 = 42,
            E55_43 = 43,
            E55_44 = 44,
            E55_45 = 45,
            E55_46 = 46,
            E55_47 = 47,
            E55_48 = 48,
            E55_49 = 49,
            E55_50 = 50,
            E55_51 = 51,
            E55_52 = 52,
            E55_53 = 53,
            E55_54 = 54,
        }

        private enum E56 : int
        {
            E56_0 = 0,
            E56_1 = 1,
            E56_2 = 2,
            E56_3 = 3,
            E56_4 = 4,
            E56_5 = 5,
            E56_6 = 6,
            E56_7 = 7,
            E56_8 = 8,
            E56_9 = 9,
            E56_10 = 10,
            E56_11 = 11,
            E56_12 = 12,
            E56_13 = 13,
            E56_14 = 14,
            E56_15 = 15,
            E56_16 = 16,
            E56_17 = 17,
            E56_18 = 18,
            E56_19 = 19,
            E56_20 = 20,
            E56_21 = 21,
            E56_22 = 22,
            E56_23 = 23,
            E56_24 = 24,
            E56_25 = 25,
            E56_26 = 26,
            E56_27 = 27,
            E56_28 = 28,
            E56_29 = 29,
            E56_30 = 30,
            E56_31 = 31,
            E56_32 = 32,
            E56_33 = 33,
            E56_34 = 34,
            E56_35 = 35,
            E56_36 = 36,
            E56_37 = 37,
            E56_38 = 38,
            E56_39 = 39,
            E56_40 = 40,
            E56_41 = 41,
            E56_42 = 42,
            E56_43 = 43,
            E56_44 = 44,
            E56_45 = 45,
            E56_46 = 46,
            E56_47 = 47,
            E56_48 = 48,
            E56_49 = 49,
            E56_50 = 50,
            E56_51 = 51,
            E56_52 = 52,
            E56_53 = 53,
            E56_54 = 54,
            E56_55 = 55,
        }

        private enum E57 : int
        {
            E57_0 = 0,
            E57_1 = 1,
            E57_2 = 2,
            E57_3 = 3,
            E57_4 = 4,
            E57_5 = 5,
            E57_6 = 6,
            E57_7 = 7,
            E57_8 = 8,
            E57_9 = 9,
            E57_10 = 10,
            E57_11 = 11,
            E57_12 = 12,
            E57_13 = 13,
            E57_14 = 14,
            E57_15 = 15,
            E57_16 = 16,
            E57_17 = 17,
            E57_18 = 18,
            E57_19 = 19,
            E57_20 = 20,
            E57_21 = 21,
            E57_22 = 22,
            E57_23 = 23,
            E57_24 = 24,
            E57_25 = 25,
            E57_26 = 26,
            E57_27 = 27,
            E57_28 = 28,
            E57_29 = 29,
            E57_30 = 30,
            E57_31 = 31,
            E57_32 = 32,
            E57_33 = 33,
            E57_34 = 34,
            E57_35 = 35,
            E57_36 = 36,
            E57_37 = 37,
            E57_38 = 38,
            E57_39 = 39,
            E57_40 = 40,
            E57_41 = 41,
            E57_42 = 42,
            E57_43 = 43,
            E57_44 = 44,
            E57_45 = 45,
            E57_46 = 46,
            E57_47 = 47,
            E57_48 = 48,
            E57_49 = 49,
            E57_50 = 50,
            E57_51 = 51,
            E57_52 = 52,
            E57_53 = 53,
            E57_54 = 54,
            E57_55 = 55,
            E57_56 = 56,
        }

        private enum E58 : int
        {
            E58_0 = 0,
            E58_1 = 1,
            E58_2 = 2,
            E58_3 = 3,
            E58_4 = 4,
            E58_5 = 5,
            E58_6 = 6,
            E58_7 = 7,
            E58_8 = 8,
            E58_9 = 9,
            E58_10 = 10,
            E58_11 = 11,
            E58_12 = 12,
            E58_13 = 13,
            E58_14 = 14,
            E58_15 = 15,
            E58_16 = 16,
            E58_17 = 17,
            E58_18 = 18,
            E58_19 = 19,
            E58_20 = 20,
            E58_21 = 21,
            E58_22 = 22,
            E58_23 = 23,
            E58_24 = 24,
            E58_25 = 25,
            E58_26 = 26,
            E58_27 = 27,
            E58_28 = 28,
            E58_29 = 29,
            E58_30 = 30,
            E58_31 = 31,
            E58_32 = 32,
            E58_33 = 33,
            E58_34 = 34,
            E58_35 = 35,
            E58_36 = 36,
            E58_37 = 37,
            E58_38 = 38,
            E58_39 = 39,
            E58_40 = 40,
            E58_41 = 41,
            E58_42 = 42,
            E58_43 = 43,
            E58_44 = 44,
            E58_45 = 45,
            E58_46 = 46,
            E58_47 = 47,
            E58_48 = 48,
            E58_49 = 49,
            E58_50 = 50,
            E58_51 = 51,
            E58_52 = 52,
            E58_53 = 53,
            E58_54 = 54,
            E58_55 = 55,
            E58_56 = 56,
            E58_57 = 57,
        }

        private enum E59 : int
        {
            E59_0 = 0,
            E59_1 = 1,
            E59_2 = 2,
            E59_3 = 3,
            E59_4 = 4,
            E59_5 = 5,
            E59_6 = 6,
            E59_7 = 7,
            E59_8 = 8,
            E59_9 = 9,
            E59_10 = 10,
            E59_11 = 11,
            E59_12 = 12,
            E59_13 = 13,
            E59_14 = 14,
            E59_15 = 15,
            E59_16 = 16,
            E59_17 = 17,
            E59_18 = 18,
            E59_19 = 19,
            E59_20 = 20,
            E59_21 = 21,
            E59_22 = 22,
            E59_23 = 23,
            E59_24 = 24,
            E59_25 = 25,
            E59_26 = 26,
            E59_27 = 27,
            E59_28 = 28,
            E59_29 = 29,
            E59_30 = 30,
            E59_31 = 31,
            E59_32 = 32,
            E59_33 = 33,
            E59_34 = 34,
            E59_35 = 35,
            E59_36 = 36,
            E59_37 = 37,
            E59_38 = 38,
            E59_39 = 39,
            E59_40 = 40,
            E59_41 = 41,
            E59_42 = 42,
            E59_43 = 43,
            E59_44 = 44,
            E59_45 = 45,
            E59_46 = 46,
            E59_47 = 47,
            E59_48 = 48,
            E59_49 = 49,
            E59_50 = 50,
            E59_51 = 51,
            E59_52 = 52,
            E59_53 = 53,
            E59_54 = 54,
            E59_55 = 55,
            E59_56 = 56,
            E59_57 = 57,
            E59_58 = 58,
        }

        private enum E60 : int
        {
            E60_0 = 0,
            E60_1 = 1,
            E60_2 = 2,
            E60_3 = 3,
            E60_4 = 4,
            E60_5 = 5,
            E60_6 = 6,
            E60_7 = 7,
            E60_8 = 8,
            E60_9 = 9,
            E60_10 = 10,
            E60_11 = 11,
            E60_12 = 12,
            E60_13 = 13,
            E60_14 = 14,
            E60_15 = 15,
            E60_16 = 16,
            E60_17 = 17,
            E60_18 = 18,
            E60_19 = 19,
            E60_20 = 20,
            E60_21 = 21,
            E60_22 = 22,
            E60_23 = 23,
            E60_24 = 24,
            E60_25 = 25,
            E60_26 = 26,
            E60_27 = 27,
            E60_28 = 28,
            E60_29 = 29,
            E60_30 = 30,
            E60_31 = 31,
            E60_32 = 32,
            E60_33 = 33,
            E60_34 = 34,
            E60_35 = 35,
            E60_36 = 36,
            E60_37 = 37,
            E60_38 = 38,
            E60_39 = 39,
            E60_40 = 40,
            E60_41 = 41,
            E60_42 = 42,
            E60_43 = 43,
            E60_44 = 44,
            E60_45 = 45,
            E60_46 = 46,
            E60_47 = 47,
            E60_48 = 48,
            E60_49 = 49,
            E60_50 = 50,
            E60_51 = 51,
            E60_52 = 52,
            E60_53 = 53,
            E60_54 = 54,
            E60_55 = 55,
            E60_56 = 56,
            E60_57 = 57,
            E60_58 = 58,
            E60_59 = 59,
        }

        private enum E61 : int
        {
            E61_0 = 0,
            E61_1 = 1,
            E61_2 = 2,
            E61_3 = 3,
            E61_4 = 4,
            E61_5 = 5,
            E61_6 = 6,
            E61_7 = 7,
            E61_8 = 8,
            E61_9 = 9,
            E61_10 = 10,
            E61_11 = 11,
            E61_12 = 12,
            E61_13 = 13,
            E61_14 = 14,
            E61_15 = 15,
            E61_16 = 16,
            E61_17 = 17,
            E61_18 = 18,
            E61_19 = 19,
            E61_20 = 20,
            E61_21 = 21,
            E61_22 = 22,
            E61_23 = 23,
            E61_24 = 24,
            E61_25 = 25,
            E61_26 = 26,
            E61_27 = 27,
            E61_28 = 28,
            E61_29 = 29,
            E61_30 = 30,
            E61_31 = 31,
            E61_32 = 32,
            E61_33 = 33,
            E61_34 = 34,
            E61_35 = 35,
            E61_36 = 36,
            E61_37 = 37,
            E61_38 = 38,
            E61_39 = 39,
            E61_40 = 40,
            E61_41 = 41,
            E61_42 = 42,
            E61_43 = 43,
            E61_44 = 44,
            E61_45 = 45,
            E61_46 = 46,
            E61_47 = 47,
            E61_48 = 48,
            E61_49 = 49,
            E61_50 = 50,
            E61_51 = 51,
            E61_52 = 52,
            E61_53 = 53,
            E61_54 = 54,
            E61_55 = 55,
            E61_56 = 56,
            E61_57 = 57,
            E61_58 = 58,
            E61_59 = 59,
            E61_60 = 60,
        }

        private enum E62 : int
        {
            E62_0 = 0,
            E62_1 = 1,
            E62_2 = 2,
            E62_3 = 3,
            E62_4 = 4,
            E62_5 = 5,
            E62_6 = 6,
            E62_7 = 7,
            E62_8 = 8,
            E62_9 = 9,
            E62_10 = 10,
            E62_11 = 11,
            E62_12 = 12,
            E62_13 = 13,
            E62_14 = 14,
            E62_15 = 15,
            E62_16 = 16,
            E62_17 = 17,
            E62_18 = 18,
            E62_19 = 19,
            E62_20 = 20,
            E62_21 = 21,
            E62_22 = 22,
            E62_23 = 23,
            E62_24 = 24,
            E62_25 = 25,
            E62_26 = 26,
            E62_27 = 27,
            E62_28 = 28,
            E62_29 = 29,
            E62_30 = 30,
            E62_31 = 31,
            E62_32 = 32,
            E62_33 = 33,
            E62_34 = 34,
            E62_35 = 35,
            E62_36 = 36,
            E62_37 = 37,
            E62_38 = 38,
            E62_39 = 39,
            E62_40 = 40,
            E62_41 = 41,
            E62_42 = 42,
            E62_43 = 43,
            E62_44 = 44,
            E62_45 = 45,
            E62_46 = 46,
            E62_47 = 47,
            E62_48 = 48,
            E62_49 = 49,
            E62_50 = 50,
            E62_51 = 51,
            E62_52 = 52,
            E62_53 = 53,
            E62_54 = 54,
            E62_55 = 55,
            E62_56 = 56,
            E62_57 = 57,
            E62_58 = 58,
            E62_59 = 59,
            E62_60 = 60,
            E62_61 = 61,
        }

        private enum E63 : int
        {
            E63_0 = 0,
            E63_1 = 1,
            E63_2 = 2,
            E63_3 = 3,
            E63_4 = 4,
            E63_5 = 5,
            E63_6 = 6,
            E63_7 = 7,
            E63_8 = 8,
            E63_9 = 9,
            E63_10 = 10,
            E63_11 = 11,
            E63_12 = 12,
            E63_13 = 13,
            E63_14 = 14,
            E63_15 = 15,
            E63_16 = 16,
            E63_17 = 17,
            E63_18 = 18,
            E63_19 = 19,
            E63_20 = 20,
            E63_21 = 21,
            E63_22 = 22,
            E63_23 = 23,
            E63_24 = 24,
            E63_25 = 25,
            E63_26 = 26,
            E63_27 = 27,
            E63_28 = 28,
            E63_29 = 29,
            E63_30 = 30,
            E63_31 = 31,
            E63_32 = 32,
            E63_33 = 33,
            E63_34 = 34,
            E63_35 = 35,
            E63_36 = 36,
            E63_37 = 37,
            E63_38 = 38,
            E63_39 = 39,
            E63_40 = 40,
            E63_41 = 41,
            E63_42 = 42,
            E63_43 = 43,
            E63_44 = 44,
            E63_45 = 45,
            E63_46 = 46,
            E63_47 = 47,
            E63_48 = 48,
            E63_49 = 49,
            E63_50 = 50,
            E63_51 = 51,
            E63_52 = 52,
            E63_53 = 53,
            E63_54 = 54,
            E63_55 = 55,
            E63_56 = 56,
            E63_57 = 57,
            E63_58 = 58,
            E63_59 = 59,
            E63_60 = 60,
            E63_61 = 61,
            E63_62 = 62,
        }

        private enum E64 : int
        {
            E64_0 = 0,
            E64_1 = 1,
            E64_2 = 2,
            E64_3 = 3,
            E64_4 = 4,
            E64_5 = 5,
            E64_6 = 6,
            E64_7 = 7,
            E64_8 = 8,
            E64_9 = 9,
            E64_10 = 10,
            E64_11 = 11,
            E64_12 = 12,
            E64_13 = 13,
            E64_14 = 14,
            E64_15 = 15,
            E64_16 = 16,
            E64_17 = 17,
            E64_18 = 18,
            E64_19 = 19,
            E64_20 = 20,
            E64_21 = 21,
            E64_22 = 22,
            E64_23 = 23,
            E64_24 = 24,
            E64_25 = 25,
            E64_26 = 26,
            E64_27 = 27,
            E64_28 = 28,
            E64_29 = 29,
            E64_30 = 30,
            E64_31 = 31,
            E64_32 = 32,
            E64_33 = 33,
            E64_34 = 34,
            E64_35 = 35,
            E64_36 = 36,
            E64_37 = 37,
            E64_38 = 38,
            E64_39 = 39,
            E64_40 = 40,
            E64_41 = 41,
            E64_42 = 42,
            E64_43 = 43,
            E64_44 = 44,
            E64_45 = 45,
            E64_46 = 46,
            E64_47 = 47,
            E64_48 = 48,
            E64_49 = 49,
            E64_50 = 50,
            E64_51 = 51,
            E64_52 = 52,
            E64_53 = 53,
            E64_54 = 54,
            E64_55 = 55,
            E64_56 = 56,
            E64_57 = 57,
            E64_58 = 58,
            E64_59 = 59,
            E64_60 = 60,
            E64_61 = 61,
            E64_62 = 62,
            E64_63 = 63,
        }

        private enum E65 : int
        {
            E65_0 = 0,
            E65_1 = 1,
            E65_2 = 2,
            E65_3 = 3,
            E65_4 = 4,
            E65_5 = 5,
            E65_6 = 6,
            E65_7 = 7,
            E65_8 = 8,
            E65_9 = 9,
            E65_10 = 10,
            E65_11 = 11,
            E65_12 = 12,
            E65_13 = 13,
            E65_14 = 14,
            E65_15 = 15,
            E65_16 = 16,
            E65_17 = 17,
            E65_18 = 18,
            E65_19 = 19,
            E65_20 = 20,
            E65_21 = 21,
            E65_22 = 22,
            E65_23 = 23,
            E65_24 = 24,
            E65_25 = 25,
            E65_26 = 26,
            E65_27 = 27,
            E65_28 = 28,
            E65_29 = 29,
            E65_30 = 30,
            E65_31 = 31,
            E65_32 = 32,
            E65_33 = 33,
            E65_34 = 34,
            E65_35 = 35,
            E65_36 = 36,
            E65_37 = 37,
            E65_38 = 38,
            E65_39 = 39,
            E65_40 = 40,
            E65_41 = 41,
            E65_42 = 42,
            E65_43 = 43,
            E65_44 = 44,
            E65_45 = 45,
            E65_46 = 46,
            E65_47 = 47,
            E65_48 = 48,
            E65_49 = 49,
            E65_50 = 50,
            E65_51 = 51,
            E65_52 = 52,
            E65_53 = 53,
            E65_54 = 54,
            E65_55 = 55,
            E65_56 = 56,
            E65_57 = 57,
            E65_58 = 58,
            E65_59 = 59,
            E65_60 = 60,
            E65_61 = 61,
            E65_62 = 62,
            E65_63 = 63,
            E65_64 = 64,
        }

        private enum E66 : int
        {
            E66_0 = 0,
            E66_1 = 1,
            E66_2 = 2,
            E66_3 = 3,
            E66_4 = 4,
            E66_5 = 5,
            E66_6 = 6,
            E66_7 = 7,
            E66_8 = 8,
            E66_9 = 9,
            E66_10 = 10,
            E66_11 = 11,
            E66_12 = 12,
            E66_13 = 13,
            E66_14 = 14,
            E66_15 = 15,
            E66_16 = 16,
            E66_17 = 17,
            E66_18 = 18,
            E66_19 = 19,
            E66_20 = 20,
            E66_21 = 21,
            E66_22 = 22,
            E66_23 = 23,
            E66_24 = 24,
            E66_25 = 25,
            E66_26 = 26,
            E66_27 = 27,
            E66_28 = 28,
            E66_29 = 29,
            E66_30 = 30,
            E66_31 = 31,
            E66_32 = 32,
            E66_33 = 33,
            E66_34 = 34,
            E66_35 = 35,
            E66_36 = 36,
            E66_37 = 37,
            E66_38 = 38,
            E66_39 = 39,
            E66_40 = 40,
            E66_41 = 41,
            E66_42 = 42,
            E66_43 = 43,
            E66_44 = 44,
            E66_45 = 45,
            E66_46 = 46,
            E66_47 = 47,
            E66_48 = 48,
            E66_49 = 49,
            E66_50 = 50,
            E66_51 = 51,
            E66_52 = 52,
            E66_53 = 53,
            E66_54 = 54,
            E66_55 = 55,
            E66_56 = 56,
            E66_57 = 57,
            E66_58 = 58,
            E66_59 = 59,
            E66_60 = 60,
            E66_61 = 61,
            E66_62 = 62,
            E66_63 = 63,
            E66_64 = 64,
            E66_65 = 65,
        }

        private enum E67 : int
        {
            E67_0 = 0,
            E67_1 = 1,
            E67_2 = 2,
            E67_3 = 3,
            E67_4 = 4,
            E67_5 = 5,
            E67_6 = 6,
            E67_7 = 7,
            E67_8 = 8,
            E67_9 = 9,
            E67_10 = 10,
            E67_11 = 11,
            E67_12 = 12,
            E67_13 = 13,
            E67_14 = 14,
            E67_15 = 15,
            E67_16 = 16,
            E67_17 = 17,
            E67_18 = 18,
            E67_19 = 19,
            E67_20 = 20,
            E67_21 = 21,
            E67_22 = 22,
            E67_23 = 23,
            E67_24 = 24,
            E67_25 = 25,
            E67_26 = 26,
            E67_27 = 27,
            E67_28 = 28,
            E67_29 = 29,
            E67_30 = 30,
            E67_31 = 31,
            E67_32 = 32,
            E67_33 = 33,
            E67_34 = 34,
            E67_35 = 35,
            E67_36 = 36,
            E67_37 = 37,
            E67_38 = 38,
            E67_39 = 39,
            E67_40 = 40,
            E67_41 = 41,
            E67_42 = 42,
            E67_43 = 43,
            E67_44 = 44,
            E67_45 = 45,
            E67_46 = 46,
            E67_47 = 47,
            E67_48 = 48,
            E67_49 = 49,
            E67_50 = 50,
            E67_51 = 51,
            E67_52 = 52,
            E67_53 = 53,
            E67_54 = 54,
            E67_55 = 55,
            E67_56 = 56,
            E67_57 = 57,
            E67_58 = 58,
            E67_59 = 59,
            E67_60 = 60,
            E67_61 = 61,
            E67_62 = 62,
            E67_63 = 63,
            E67_64 = 64,
            E67_65 = 65,
            E67_66 = 66,
        }

        private enum E68 : int
        {
            E68_0 = 0,
            E68_1 = 1,
            E68_2 = 2,
            E68_3 = 3,
            E68_4 = 4,
            E68_5 = 5,
            E68_6 = 6,
            E68_7 = 7,
            E68_8 = 8,
            E68_9 = 9,
            E68_10 = 10,
            E68_11 = 11,
            E68_12 = 12,
            E68_13 = 13,
            E68_14 = 14,
            E68_15 = 15,
            E68_16 = 16,
            E68_17 = 17,
            E68_18 = 18,
            E68_19 = 19,
            E68_20 = 20,
            E68_21 = 21,
            E68_22 = 22,
            E68_23 = 23,
            E68_24 = 24,
            E68_25 = 25,
            E68_26 = 26,
            E68_27 = 27,
            E68_28 = 28,
            E68_29 = 29,
            E68_30 = 30,
            E68_31 = 31,
            E68_32 = 32,
            E68_33 = 33,
            E68_34 = 34,
            E68_35 = 35,
            E68_36 = 36,
            E68_37 = 37,
            E68_38 = 38,
            E68_39 = 39,
            E68_40 = 40,
            E68_41 = 41,
            E68_42 = 42,
            E68_43 = 43,
            E68_44 = 44,
            E68_45 = 45,
            E68_46 = 46,
            E68_47 = 47,
            E68_48 = 48,
            E68_49 = 49,
            E68_50 = 50,
            E68_51 = 51,
            E68_52 = 52,
            E68_53 = 53,
            E68_54 = 54,
            E68_55 = 55,
            E68_56 = 56,
            E68_57 = 57,
            E68_58 = 58,
            E68_59 = 59,
            E68_60 = 60,
            E68_61 = 61,
            E68_62 = 62,
            E68_63 = 63,
            E68_64 = 64,
            E68_65 = 65,
            E68_66 = 66,
            E68_67 = 67,
        }

        private enum E69 : int
        {
            E69_0 = 0,
            E69_1 = 1,
            E69_2 = 2,
            E69_3 = 3,
            E69_4 = 4,
            E69_5 = 5,
            E69_6 = 6,
            E69_7 = 7,
            E69_8 = 8,
            E69_9 = 9,
            E69_10 = 10,
            E69_11 = 11,
            E69_12 = 12,
            E69_13 = 13,
            E69_14 = 14,
            E69_15 = 15,
            E69_16 = 16,
            E69_17 = 17,
            E69_18 = 18,
            E69_19 = 19,
            E69_20 = 20,
            E69_21 = 21,
            E69_22 = 22,
            E69_23 = 23,
            E69_24 = 24,
            E69_25 = 25,
            E69_26 = 26,
            E69_27 = 27,
            E69_28 = 28,
            E69_29 = 29,
            E69_30 = 30,
            E69_31 = 31,
            E69_32 = 32,
            E69_33 = 33,
            E69_34 = 34,
            E69_35 = 35,
            E69_36 = 36,
            E69_37 = 37,
            E69_38 = 38,
            E69_39 = 39,
            E69_40 = 40,
            E69_41 = 41,
            E69_42 = 42,
            E69_43 = 43,
            E69_44 = 44,
            E69_45 = 45,
            E69_46 = 46,
            E69_47 = 47,
            E69_48 = 48,
            E69_49 = 49,
            E69_50 = 50,
            E69_51 = 51,
            E69_52 = 52,
            E69_53 = 53,
            E69_54 = 54,
            E69_55 = 55,
            E69_56 = 56,
            E69_57 = 57,
            E69_58 = 58,
            E69_59 = 59,
            E69_60 = 60,
            E69_61 = 61,
            E69_62 = 62,
            E69_63 = 63,
            E69_64 = 64,
            E69_65 = 65,
            E69_66 = 66,
            E69_67 = 67,
            E69_68 = 68,
        }

        private enum E70 : int
        {
            E70_0 = 0,
            E70_1 = 1,
            E70_2 = 2,
            E70_3 = 3,
            E70_4 = 4,
            E70_5 = 5,
            E70_6 = 6,
            E70_7 = 7,
            E70_8 = 8,
            E70_9 = 9,
            E70_10 = 10,
            E70_11 = 11,
            E70_12 = 12,
            E70_13 = 13,
            E70_14 = 14,
            E70_15 = 15,
            E70_16 = 16,
            E70_17 = 17,
            E70_18 = 18,
            E70_19 = 19,
            E70_20 = 20,
            E70_21 = 21,
            E70_22 = 22,
            E70_23 = 23,
            E70_24 = 24,
            E70_25 = 25,
            E70_26 = 26,
            E70_27 = 27,
            E70_28 = 28,
            E70_29 = 29,
            E70_30 = 30,
            E70_31 = 31,
            E70_32 = 32,
            E70_33 = 33,
            E70_34 = 34,
            E70_35 = 35,
            E70_36 = 36,
            E70_37 = 37,
            E70_38 = 38,
            E70_39 = 39,
            E70_40 = 40,
            E70_41 = 41,
            E70_42 = 42,
            E70_43 = 43,
            E70_44 = 44,
            E70_45 = 45,
            E70_46 = 46,
            E70_47 = 47,
            E70_48 = 48,
            E70_49 = 49,
            E70_50 = 50,
            E70_51 = 51,
            E70_52 = 52,
            E70_53 = 53,
            E70_54 = 54,
            E70_55 = 55,
            E70_56 = 56,
            E70_57 = 57,
            E70_58 = 58,
            E70_59 = 59,
            E70_60 = 60,
            E70_61 = 61,
            E70_62 = 62,
            E70_63 = 63,
            E70_64 = 64,
            E70_65 = 65,
            E70_66 = 66,
            E70_67 = 67,
            E70_68 = 68,
            E70_69 = 69,
        }

        private enum E71 : int
        {
            E71_0 = 0,
            E71_1 = 1,
            E71_2 = 2,
            E71_3 = 3,
            E71_4 = 4,
            E71_5 = 5,
            E71_6 = 6,
            E71_7 = 7,
            E71_8 = 8,
            E71_9 = 9,
            E71_10 = 10,
            E71_11 = 11,
            E71_12 = 12,
            E71_13 = 13,
            E71_14 = 14,
            E71_15 = 15,
            E71_16 = 16,
            E71_17 = 17,
            E71_18 = 18,
            E71_19 = 19,
            E71_20 = 20,
            E71_21 = 21,
            E71_22 = 22,
            E71_23 = 23,
            E71_24 = 24,
            E71_25 = 25,
            E71_26 = 26,
            E71_27 = 27,
            E71_28 = 28,
            E71_29 = 29,
            E71_30 = 30,
            E71_31 = 31,
            E71_32 = 32,
            E71_33 = 33,
            E71_34 = 34,
            E71_35 = 35,
            E71_36 = 36,
            E71_37 = 37,
            E71_38 = 38,
            E71_39 = 39,
            E71_40 = 40,
            E71_41 = 41,
            E71_42 = 42,
            E71_43 = 43,
            E71_44 = 44,
            E71_45 = 45,
            E71_46 = 46,
            E71_47 = 47,
            E71_48 = 48,
            E71_49 = 49,
            E71_50 = 50,
            E71_51 = 51,
            E71_52 = 52,
            E71_53 = 53,
            E71_54 = 54,
            E71_55 = 55,
            E71_56 = 56,
            E71_57 = 57,
            E71_58 = 58,
            E71_59 = 59,
            E71_60 = 60,
            E71_61 = 61,
            E71_62 = 62,
            E71_63 = 63,
            E71_64 = 64,
            E71_65 = 65,
            E71_66 = 66,
            E71_67 = 67,
            E71_68 = 68,
            E71_69 = 69,
            E71_70 = 70,
        }

        private enum E72 : int
        {
            E72_0 = 0,
            E72_1 = 1,
            E72_2 = 2,
            E72_3 = 3,
            E72_4 = 4,
            E72_5 = 5,
            E72_6 = 6,
            E72_7 = 7,
            E72_8 = 8,
            E72_9 = 9,
            E72_10 = 10,
            E72_11 = 11,
            E72_12 = 12,
            E72_13 = 13,
            E72_14 = 14,
            E72_15 = 15,
            E72_16 = 16,
            E72_17 = 17,
            E72_18 = 18,
            E72_19 = 19,
            E72_20 = 20,
            E72_21 = 21,
            E72_22 = 22,
            E72_23 = 23,
            E72_24 = 24,
            E72_25 = 25,
            E72_26 = 26,
            E72_27 = 27,
            E72_28 = 28,
            E72_29 = 29,
            E72_30 = 30,
            E72_31 = 31,
            E72_32 = 32,
            E72_33 = 33,
            E72_34 = 34,
            E72_35 = 35,
            E72_36 = 36,
            E72_37 = 37,
            E72_38 = 38,
            E72_39 = 39,
            E72_40 = 40,
            E72_41 = 41,
            E72_42 = 42,
            E72_43 = 43,
            E72_44 = 44,
            E72_45 = 45,
            E72_46 = 46,
            E72_47 = 47,
            E72_48 = 48,
            E72_49 = 49,
            E72_50 = 50,
            E72_51 = 51,
            E72_52 = 52,
            E72_53 = 53,
            E72_54 = 54,
            E72_55 = 55,
            E72_56 = 56,
            E72_57 = 57,
            E72_58 = 58,
            E72_59 = 59,
            E72_60 = 60,
            E72_61 = 61,
            E72_62 = 62,
            E72_63 = 63,
            E72_64 = 64,
            E72_65 = 65,
            E72_66 = 66,
            E72_67 = 67,
            E72_68 = 68,
            E72_69 = 69,
            E72_70 = 70,
            E72_71 = 71,
        }

        private enum E73 : int
        {
            E73_0 = 0,
            E73_1 = 1,
            E73_2 = 2,
            E73_3 = 3,
            E73_4 = 4,
            E73_5 = 5,
            E73_6 = 6,
            E73_7 = 7,
            E73_8 = 8,
            E73_9 = 9,
            E73_10 = 10,
            E73_11 = 11,
            E73_12 = 12,
            E73_13 = 13,
            E73_14 = 14,
            E73_15 = 15,
            E73_16 = 16,
            E73_17 = 17,
            E73_18 = 18,
            E73_19 = 19,
            E73_20 = 20,
            E73_21 = 21,
            E73_22 = 22,
            E73_23 = 23,
            E73_24 = 24,
            E73_25 = 25,
            E73_26 = 26,
            E73_27 = 27,
            E73_28 = 28,
            E73_29 = 29,
            E73_30 = 30,
            E73_31 = 31,
            E73_32 = 32,
            E73_33 = 33,
            E73_34 = 34,
            E73_35 = 35,
            E73_36 = 36,
            E73_37 = 37,
            E73_38 = 38,
            E73_39 = 39,
            E73_40 = 40,
            E73_41 = 41,
            E73_42 = 42,
            E73_43 = 43,
            E73_44 = 44,
            E73_45 = 45,
            E73_46 = 46,
            E73_47 = 47,
            E73_48 = 48,
            E73_49 = 49,
            E73_50 = 50,
            E73_51 = 51,
            E73_52 = 52,
            E73_53 = 53,
            E73_54 = 54,
            E73_55 = 55,
            E73_56 = 56,
            E73_57 = 57,
            E73_58 = 58,
            E73_59 = 59,
            E73_60 = 60,
            E73_61 = 61,
            E73_62 = 62,
            E73_63 = 63,
            E73_64 = 64,
            E73_65 = 65,
            E73_66 = 66,
            E73_67 = 67,
            E73_68 = 68,
            E73_69 = 69,
            E73_70 = 70,
            E73_71 = 71,
            E73_72 = 72,
        }

        private enum E74 : int
        {
            E74_0 = 0,
            E74_1 = 1,
            E74_2 = 2,
            E74_3 = 3,
            E74_4 = 4,
            E74_5 = 5,
            E74_6 = 6,
            E74_7 = 7,
            E74_8 = 8,
            E74_9 = 9,
            E74_10 = 10,
            E74_11 = 11,
            E74_12 = 12,
            E74_13 = 13,
            E74_14 = 14,
            E74_15 = 15,
            E74_16 = 16,
            E74_17 = 17,
            E74_18 = 18,
            E74_19 = 19,
            E74_20 = 20,
            E74_21 = 21,
            E74_22 = 22,
            E74_23 = 23,
            E74_24 = 24,
            E74_25 = 25,
            E74_26 = 26,
            E74_27 = 27,
            E74_28 = 28,
            E74_29 = 29,
            E74_30 = 30,
            E74_31 = 31,
            E74_32 = 32,
            E74_33 = 33,
            E74_34 = 34,
            E74_35 = 35,
            E74_36 = 36,
            E74_37 = 37,
            E74_38 = 38,
            E74_39 = 39,
            E74_40 = 40,
            E74_41 = 41,
            E74_42 = 42,
            E74_43 = 43,
            E74_44 = 44,
            E74_45 = 45,
            E74_46 = 46,
            E74_47 = 47,
            E74_48 = 48,
            E74_49 = 49,
            E74_50 = 50,
            E74_51 = 51,
            E74_52 = 52,
            E74_53 = 53,
            E74_54 = 54,
            E74_55 = 55,
            E74_56 = 56,
            E74_57 = 57,
            E74_58 = 58,
            E74_59 = 59,
            E74_60 = 60,
            E74_61 = 61,
            E74_62 = 62,
            E74_63 = 63,
            E74_64 = 64,
            E74_65 = 65,
            E74_66 = 66,
            E74_67 = 67,
            E74_68 = 68,
            E74_69 = 69,
            E74_70 = 70,
            E74_71 = 71,
            E74_72 = 72,
            E74_73 = 73,
        }

        private enum E75 : int
        {
            E75_0 = 0,
            E75_1 = 1,
            E75_2 = 2,
            E75_3 = 3,
            E75_4 = 4,
            E75_5 = 5,
            E75_6 = 6,
            E75_7 = 7,
            E75_8 = 8,
            E75_9 = 9,
            E75_10 = 10,
            E75_11 = 11,
            E75_12 = 12,
            E75_13 = 13,
            E75_14 = 14,
            E75_15 = 15,
            E75_16 = 16,
            E75_17 = 17,
            E75_18 = 18,
            E75_19 = 19,
            E75_20 = 20,
            E75_21 = 21,
            E75_22 = 22,
            E75_23 = 23,
            E75_24 = 24,
            E75_25 = 25,
            E75_26 = 26,
            E75_27 = 27,
            E75_28 = 28,
            E75_29 = 29,
            E75_30 = 30,
            E75_31 = 31,
            E75_32 = 32,
            E75_33 = 33,
            E75_34 = 34,
            E75_35 = 35,
            E75_36 = 36,
            E75_37 = 37,
            E75_38 = 38,
            E75_39 = 39,
            E75_40 = 40,
            E75_41 = 41,
            E75_42 = 42,
            E75_43 = 43,
            E75_44 = 44,
            E75_45 = 45,
            E75_46 = 46,
            E75_47 = 47,
            E75_48 = 48,
            E75_49 = 49,
            E75_50 = 50,
            E75_51 = 51,
            E75_52 = 52,
            E75_53 = 53,
            E75_54 = 54,
            E75_55 = 55,
            E75_56 = 56,
            E75_57 = 57,
            E75_58 = 58,
            E75_59 = 59,
            E75_60 = 60,
            E75_61 = 61,
            E75_62 = 62,
            E75_63 = 63,
            E75_64 = 64,
            E75_65 = 65,
            E75_66 = 66,
            E75_67 = 67,
            E75_68 = 68,
            E75_69 = 69,
            E75_70 = 70,
            E75_71 = 71,
            E75_72 = 72,
            E75_73 = 73,
            E75_74 = 74,
        }

        private enum E76 : int
        {
            E76_0 = 0,
            E76_1 = 1,
            E76_2 = 2,
            E76_3 = 3,
            E76_4 = 4,
            E76_5 = 5,
            E76_6 = 6,
            E76_7 = 7,
            E76_8 = 8,
            E76_9 = 9,
            E76_10 = 10,
            E76_11 = 11,
            E76_12 = 12,
            E76_13 = 13,
            E76_14 = 14,
            E76_15 = 15,
            E76_16 = 16,
            E76_17 = 17,
            E76_18 = 18,
            E76_19 = 19,
            E76_20 = 20,
            E76_21 = 21,
            E76_22 = 22,
            E76_23 = 23,
            E76_24 = 24,
            E76_25 = 25,
            E76_26 = 26,
            E76_27 = 27,
            E76_28 = 28,
            E76_29 = 29,
            E76_30 = 30,
            E76_31 = 31,
            E76_32 = 32,
            E76_33 = 33,
            E76_34 = 34,
            E76_35 = 35,
            E76_36 = 36,
            E76_37 = 37,
            E76_38 = 38,
            E76_39 = 39,
            E76_40 = 40,
            E76_41 = 41,
            E76_42 = 42,
            E76_43 = 43,
            E76_44 = 44,
            E76_45 = 45,
            E76_46 = 46,
            E76_47 = 47,
            E76_48 = 48,
            E76_49 = 49,
            E76_50 = 50,
            E76_51 = 51,
            E76_52 = 52,
            E76_53 = 53,
            E76_54 = 54,
            E76_55 = 55,
            E76_56 = 56,
            E76_57 = 57,
            E76_58 = 58,
            E76_59 = 59,
            E76_60 = 60,
            E76_61 = 61,
            E76_62 = 62,
            E76_63 = 63,
            E76_64 = 64,
            E76_65 = 65,
            E76_66 = 66,
            E76_67 = 67,
            E76_68 = 68,
            E76_69 = 69,
            E76_70 = 70,
            E76_71 = 71,
            E76_72 = 72,
            E76_73 = 73,
            E76_74 = 74,
            E76_75 = 75,
        }

        private enum E77 : int
        {
            E77_0 = 0,
            E77_1 = 1,
            E77_2 = 2,
            E77_3 = 3,
            E77_4 = 4,
            E77_5 = 5,
            E77_6 = 6,
            E77_7 = 7,
            E77_8 = 8,
            E77_9 = 9,
            E77_10 = 10,
            E77_11 = 11,
            E77_12 = 12,
            E77_13 = 13,
            E77_14 = 14,
            E77_15 = 15,
            E77_16 = 16,
            E77_17 = 17,
            E77_18 = 18,
            E77_19 = 19,
            E77_20 = 20,
            E77_21 = 21,
            E77_22 = 22,
            E77_23 = 23,
            E77_24 = 24,
            E77_25 = 25,
            E77_26 = 26,
            E77_27 = 27,
            E77_28 = 28,
            E77_29 = 29,
            E77_30 = 30,
            E77_31 = 31,
            E77_32 = 32,
            E77_33 = 33,
            E77_34 = 34,
            E77_35 = 35,
            E77_36 = 36,
            E77_37 = 37,
            E77_38 = 38,
            E77_39 = 39,
            E77_40 = 40,
            E77_41 = 41,
            E77_42 = 42,
            E77_43 = 43,
            E77_44 = 44,
            E77_45 = 45,
            E77_46 = 46,
            E77_47 = 47,
            E77_48 = 48,
            E77_49 = 49,
            E77_50 = 50,
            E77_51 = 51,
            E77_52 = 52,
            E77_53 = 53,
            E77_54 = 54,
            E77_55 = 55,
            E77_56 = 56,
            E77_57 = 57,
            E77_58 = 58,
            E77_59 = 59,
            E77_60 = 60,
            E77_61 = 61,
            E77_62 = 62,
            E77_63 = 63,
            E77_64 = 64,
            E77_65 = 65,
            E77_66 = 66,
            E77_67 = 67,
            E77_68 = 68,
            E77_69 = 69,
            E77_70 = 70,
            E77_71 = 71,
            E77_72 = 72,
            E77_73 = 73,
            E77_74 = 74,
            E77_75 = 75,
            E77_76 = 76,
        }

        private enum E78 : int
        {
            E78_0 = 0,
            E78_1 = 1,
            E78_2 = 2,
            E78_3 = 3,
            E78_4 = 4,
            E78_5 = 5,
            E78_6 = 6,
            E78_7 = 7,
            E78_8 = 8,
            E78_9 = 9,
            E78_10 = 10,
            E78_11 = 11,
            E78_12 = 12,
            E78_13 = 13,
            E78_14 = 14,
            E78_15 = 15,
            E78_16 = 16,
            E78_17 = 17,
            E78_18 = 18,
            E78_19 = 19,
            E78_20 = 20,
            E78_21 = 21,
            E78_22 = 22,
            E78_23 = 23,
            E78_24 = 24,
            E78_25 = 25,
            E78_26 = 26,
            E78_27 = 27,
            E78_28 = 28,
            E78_29 = 29,
            E78_30 = 30,
            E78_31 = 31,
            E78_32 = 32,
            E78_33 = 33,
            E78_34 = 34,
            E78_35 = 35,
            E78_36 = 36,
            E78_37 = 37,
            E78_38 = 38,
            E78_39 = 39,
            E78_40 = 40,
            E78_41 = 41,
            E78_42 = 42,
            E78_43 = 43,
            E78_44 = 44,
            E78_45 = 45,
            E78_46 = 46,
            E78_47 = 47,
            E78_48 = 48,
            E78_49 = 49,
            E78_50 = 50,
            E78_51 = 51,
            E78_52 = 52,
            E78_53 = 53,
            E78_54 = 54,
            E78_55 = 55,
            E78_56 = 56,
            E78_57 = 57,
            E78_58 = 58,
            E78_59 = 59,
            E78_60 = 60,
            E78_61 = 61,
            E78_62 = 62,
            E78_63 = 63,
            E78_64 = 64,
            E78_65 = 65,
            E78_66 = 66,
            E78_67 = 67,
            E78_68 = 68,
            E78_69 = 69,
            E78_70 = 70,
            E78_71 = 71,
            E78_72 = 72,
            E78_73 = 73,
            E78_74 = 74,
            E78_75 = 75,
            E78_76 = 76,
            E78_77 = 77,
        }

        private enum E79 : int
        {
            E79_0 = 0,
            E79_1 = 1,
            E79_2 = 2,
            E79_3 = 3,
            E79_4 = 4,
            E79_5 = 5,
            E79_6 = 6,
            E79_7 = 7,
            E79_8 = 8,
            E79_9 = 9,
            E79_10 = 10,
            E79_11 = 11,
            E79_12 = 12,
            E79_13 = 13,
            E79_14 = 14,
            E79_15 = 15,
            E79_16 = 16,
            E79_17 = 17,
            E79_18 = 18,
            E79_19 = 19,
            E79_20 = 20,
            E79_21 = 21,
            E79_22 = 22,
            E79_23 = 23,
            E79_24 = 24,
            E79_25 = 25,
            E79_26 = 26,
            E79_27 = 27,
            E79_28 = 28,
            E79_29 = 29,
            E79_30 = 30,
            E79_31 = 31,
            E79_32 = 32,
            E79_33 = 33,
            E79_34 = 34,
            E79_35 = 35,
            E79_36 = 36,
            E79_37 = 37,
            E79_38 = 38,
            E79_39 = 39,
            E79_40 = 40,
            E79_41 = 41,
            E79_42 = 42,
            E79_43 = 43,
            E79_44 = 44,
            E79_45 = 45,
            E79_46 = 46,
            E79_47 = 47,
            E79_48 = 48,
            E79_49 = 49,
            E79_50 = 50,
            E79_51 = 51,
            E79_52 = 52,
            E79_53 = 53,
            E79_54 = 54,
            E79_55 = 55,
            E79_56 = 56,
            E79_57 = 57,
            E79_58 = 58,
            E79_59 = 59,
            E79_60 = 60,
            E79_61 = 61,
            E79_62 = 62,
            E79_63 = 63,
            E79_64 = 64,
            E79_65 = 65,
            E79_66 = 66,
            E79_67 = 67,
            E79_68 = 68,
            E79_69 = 69,
            E79_70 = 70,
            E79_71 = 71,
            E79_72 = 72,
            E79_73 = 73,
            E79_74 = 74,
            E79_75 = 75,
            E79_76 = 76,
            E79_77 = 77,
            E79_78 = 78,
        }

        private enum E80 : int
        {
            E80_0 = 0,
            E80_1 = 1,
            E80_2 = 2,
            E80_3 = 3,
            E80_4 = 4,
            E80_5 = 5,
            E80_6 = 6,
            E80_7 = 7,
            E80_8 = 8,
            E80_9 = 9,
            E80_10 = 10,
            E80_11 = 11,
            E80_12 = 12,
            E80_13 = 13,
            E80_14 = 14,
            E80_15 = 15,
            E80_16 = 16,
            E80_17 = 17,
            E80_18 = 18,
            E80_19 = 19,
            E80_20 = 20,
            E80_21 = 21,
            E80_22 = 22,
            E80_23 = 23,
            E80_24 = 24,
            E80_25 = 25,
            E80_26 = 26,
            E80_27 = 27,
            E80_28 = 28,
            E80_29 = 29,
            E80_30 = 30,
            E80_31 = 31,
            E80_32 = 32,
            E80_33 = 33,
            E80_34 = 34,
            E80_35 = 35,
            E80_36 = 36,
            E80_37 = 37,
            E80_38 = 38,
            E80_39 = 39,
            E80_40 = 40,
            E80_41 = 41,
            E80_42 = 42,
            E80_43 = 43,
            E80_44 = 44,
            E80_45 = 45,
            E80_46 = 46,
            E80_47 = 47,
            E80_48 = 48,
            E80_49 = 49,
            E80_50 = 50,
            E80_51 = 51,
            E80_52 = 52,
            E80_53 = 53,
            E80_54 = 54,
            E80_55 = 55,
            E80_56 = 56,
            E80_57 = 57,
            E80_58 = 58,
            E80_59 = 59,
            E80_60 = 60,
            E80_61 = 61,
            E80_62 = 62,
            E80_63 = 63,
            E80_64 = 64,
            E80_65 = 65,
            E80_66 = 66,
            E80_67 = 67,
            E80_68 = 68,
            E80_69 = 69,
            E80_70 = 70,
            E80_71 = 71,
            E80_72 = 72,
            E80_73 = 73,
            E80_74 = 74,
            E80_75 = 75,
            E80_76 = 76,
            E80_77 = 77,
            E80_78 = 78,
            E80_79 = 79,
        }

        private enum E81 : int
        {
            E81_0 = 0,
            E81_1 = 1,
            E81_2 = 2,
            E81_3 = 3,
            E81_4 = 4,
            E81_5 = 5,
            E81_6 = 6,
            E81_7 = 7,
            E81_8 = 8,
            E81_9 = 9,
            E81_10 = 10,
            E81_11 = 11,
            E81_12 = 12,
            E81_13 = 13,
            E81_14 = 14,
            E81_15 = 15,
            E81_16 = 16,
            E81_17 = 17,
            E81_18 = 18,
            E81_19 = 19,
            E81_20 = 20,
            E81_21 = 21,
            E81_22 = 22,
            E81_23 = 23,
            E81_24 = 24,
            E81_25 = 25,
            E81_26 = 26,
            E81_27 = 27,
            E81_28 = 28,
            E81_29 = 29,
            E81_30 = 30,
            E81_31 = 31,
            E81_32 = 32,
            E81_33 = 33,
            E81_34 = 34,
            E81_35 = 35,
            E81_36 = 36,
            E81_37 = 37,
            E81_38 = 38,
            E81_39 = 39,
            E81_40 = 40,
            E81_41 = 41,
            E81_42 = 42,
            E81_43 = 43,
            E81_44 = 44,
            E81_45 = 45,
            E81_46 = 46,
            E81_47 = 47,
            E81_48 = 48,
            E81_49 = 49,
            E81_50 = 50,
            E81_51 = 51,
            E81_52 = 52,
            E81_53 = 53,
            E81_54 = 54,
            E81_55 = 55,
            E81_56 = 56,
            E81_57 = 57,
            E81_58 = 58,
            E81_59 = 59,
            E81_60 = 60,
            E81_61 = 61,
            E81_62 = 62,
            E81_63 = 63,
            E81_64 = 64,
            E81_65 = 65,
            E81_66 = 66,
            E81_67 = 67,
            E81_68 = 68,
            E81_69 = 69,
            E81_70 = 70,
            E81_71 = 71,
            E81_72 = 72,
            E81_73 = 73,
            E81_74 = 74,
            E81_75 = 75,
            E81_76 = 76,
            E81_77 = 77,
            E81_78 = 78,
            E81_79 = 79,
            E81_80 = 80,
        }

        private enum E82 : int
        {
            E82_0 = 0,
            E82_1 = 1,
            E82_2 = 2,
            E82_3 = 3,
            E82_4 = 4,
            E82_5 = 5,
            E82_6 = 6,
            E82_7 = 7,
            E82_8 = 8,
            E82_9 = 9,
            E82_10 = 10,
            E82_11 = 11,
            E82_12 = 12,
            E82_13 = 13,
            E82_14 = 14,
            E82_15 = 15,
            E82_16 = 16,
            E82_17 = 17,
            E82_18 = 18,
            E82_19 = 19,
            E82_20 = 20,
            E82_21 = 21,
            E82_22 = 22,
            E82_23 = 23,
            E82_24 = 24,
            E82_25 = 25,
            E82_26 = 26,
            E82_27 = 27,
            E82_28 = 28,
            E82_29 = 29,
            E82_30 = 30,
            E82_31 = 31,
            E82_32 = 32,
            E82_33 = 33,
            E82_34 = 34,
            E82_35 = 35,
            E82_36 = 36,
            E82_37 = 37,
            E82_38 = 38,
            E82_39 = 39,
            E82_40 = 40,
            E82_41 = 41,
            E82_42 = 42,
            E82_43 = 43,
            E82_44 = 44,
            E82_45 = 45,
            E82_46 = 46,
            E82_47 = 47,
            E82_48 = 48,
            E82_49 = 49,
            E82_50 = 50,
            E82_51 = 51,
            E82_52 = 52,
            E82_53 = 53,
            E82_54 = 54,
            E82_55 = 55,
            E82_56 = 56,
            E82_57 = 57,
            E82_58 = 58,
            E82_59 = 59,
            E82_60 = 60,
            E82_61 = 61,
            E82_62 = 62,
            E82_63 = 63,
            E82_64 = 64,
            E82_65 = 65,
            E82_66 = 66,
            E82_67 = 67,
            E82_68 = 68,
            E82_69 = 69,
            E82_70 = 70,
            E82_71 = 71,
            E82_72 = 72,
            E82_73 = 73,
            E82_74 = 74,
            E82_75 = 75,
            E82_76 = 76,
            E82_77 = 77,
            E82_78 = 78,
            E82_79 = 79,
            E82_80 = 80,
            E82_81 = 81,
        }

        private enum E83 : int
        {
            E83_0 = 0,
            E83_1 = 1,
            E83_2 = 2,
            E83_3 = 3,
            E83_4 = 4,
            E83_5 = 5,
            E83_6 = 6,
            E83_7 = 7,
            E83_8 = 8,
            E83_9 = 9,
            E83_10 = 10,
            E83_11 = 11,
            E83_12 = 12,
            E83_13 = 13,
            E83_14 = 14,
            E83_15 = 15,
            E83_16 = 16,
            E83_17 = 17,
            E83_18 = 18,
            E83_19 = 19,
            E83_20 = 20,
            E83_21 = 21,
            E83_22 = 22,
            E83_23 = 23,
            E83_24 = 24,
            E83_25 = 25,
            E83_26 = 26,
            E83_27 = 27,
            E83_28 = 28,
            E83_29 = 29,
            E83_30 = 30,
            E83_31 = 31,
            E83_32 = 32,
            E83_33 = 33,
            E83_34 = 34,
            E83_35 = 35,
            E83_36 = 36,
            E83_37 = 37,
            E83_38 = 38,
            E83_39 = 39,
            E83_40 = 40,
            E83_41 = 41,
            E83_42 = 42,
            E83_43 = 43,
            E83_44 = 44,
            E83_45 = 45,
            E83_46 = 46,
            E83_47 = 47,
            E83_48 = 48,
            E83_49 = 49,
            E83_50 = 50,
            E83_51 = 51,
            E83_52 = 52,
            E83_53 = 53,
            E83_54 = 54,
            E83_55 = 55,
            E83_56 = 56,
            E83_57 = 57,
            E83_58 = 58,
            E83_59 = 59,
            E83_60 = 60,
            E83_61 = 61,
            E83_62 = 62,
            E83_63 = 63,
            E83_64 = 64,
            E83_65 = 65,
            E83_66 = 66,
            E83_67 = 67,
            E83_68 = 68,
            E83_69 = 69,
            E83_70 = 70,
            E83_71 = 71,
            E83_72 = 72,
            E83_73 = 73,
            E83_74 = 74,
            E83_75 = 75,
            E83_76 = 76,
            E83_77 = 77,
            E83_78 = 78,
            E83_79 = 79,
            E83_80 = 80,
            E83_81 = 81,
            E83_82 = 82,
        }

        private enum E84 : int
        {
            E84_0 = 0,
            E84_1 = 1,
            E84_2 = 2,
            E84_3 = 3,
            E84_4 = 4,
            E84_5 = 5,
            E84_6 = 6,
            E84_7 = 7,
            E84_8 = 8,
            E84_9 = 9,
            E84_10 = 10,
            E84_11 = 11,
            E84_12 = 12,
            E84_13 = 13,
            E84_14 = 14,
            E84_15 = 15,
            E84_16 = 16,
            E84_17 = 17,
            E84_18 = 18,
            E84_19 = 19,
            E84_20 = 20,
            E84_21 = 21,
            E84_22 = 22,
            E84_23 = 23,
            E84_24 = 24,
            E84_25 = 25,
            E84_26 = 26,
            E84_27 = 27,
            E84_28 = 28,
            E84_29 = 29,
            E84_30 = 30,
            E84_31 = 31,
            E84_32 = 32,
            E84_33 = 33,
            E84_34 = 34,
            E84_35 = 35,
            E84_36 = 36,
            E84_37 = 37,
            E84_38 = 38,
            E84_39 = 39,
            E84_40 = 40,
            E84_41 = 41,
            E84_42 = 42,
            E84_43 = 43,
            E84_44 = 44,
            E84_45 = 45,
            E84_46 = 46,
            E84_47 = 47,
            E84_48 = 48,
            E84_49 = 49,
            E84_50 = 50,
            E84_51 = 51,
            E84_52 = 52,
            E84_53 = 53,
            E84_54 = 54,
            E84_55 = 55,
            E84_56 = 56,
            E84_57 = 57,
            E84_58 = 58,
            E84_59 = 59,
            E84_60 = 60,
            E84_61 = 61,
            E84_62 = 62,
            E84_63 = 63,
            E84_64 = 64,
            E84_65 = 65,
            E84_66 = 66,
            E84_67 = 67,
            E84_68 = 68,
            E84_69 = 69,
            E84_70 = 70,
            E84_71 = 71,
            E84_72 = 72,
            E84_73 = 73,
            E84_74 = 74,
            E84_75 = 75,
            E84_76 = 76,
            E84_77 = 77,
            E84_78 = 78,
            E84_79 = 79,
            E84_80 = 80,
            E84_81 = 81,
            E84_82 = 82,
            E84_83 = 83,
        }

        private enum E85 : int
        {
            E85_0 = 0,
            E85_1 = 1,
            E85_2 = 2,
            E85_3 = 3,
            E85_4 = 4,
            E85_5 = 5,
            E85_6 = 6,
            E85_7 = 7,
            E85_8 = 8,
            E85_9 = 9,
            E85_10 = 10,
            E85_11 = 11,
            E85_12 = 12,
            E85_13 = 13,
            E85_14 = 14,
            E85_15 = 15,
            E85_16 = 16,
            E85_17 = 17,
            E85_18 = 18,
            E85_19 = 19,
            E85_20 = 20,
            E85_21 = 21,
            E85_22 = 22,
            E85_23 = 23,
            E85_24 = 24,
            E85_25 = 25,
            E85_26 = 26,
            E85_27 = 27,
            E85_28 = 28,
            E85_29 = 29,
            E85_30 = 30,
            E85_31 = 31,
            E85_32 = 32,
            E85_33 = 33,
            E85_34 = 34,
            E85_35 = 35,
            E85_36 = 36,
            E85_37 = 37,
            E85_38 = 38,
            E85_39 = 39,
            E85_40 = 40,
            E85_41 = 41,
            E85_42 = 42,
            E85_43 = 43,
            E85_44 = 44,
            E85_45 = 45,
            E85_46 = 46,
            E85_47 = 47,
            E85_48 = 48,
            E85_49 = 49,
            E85_50 = 50,
            E85_51 = 51,
            E85_52 = 52,
            E85_53 = 53,
            E85_54 = 54,
            E85_55 = 55,
            E85_56 = 56,
            E85_57 = 57,
            E85_58 = 58,
            E85_59 = 59,
            E85_60 = 60,
            E85_61 = 61,
            E85_62 = 62,
            E85_63 = 63,
            E85_64 = 64,
            E85_65 = 65,
            E85_66 = 66,
            E85_67 = 67,
            E85_68 = 68,
            E85_69 = 69,
            E85_70 = 70,
            E85_71 = 71,
            E85_72 = 72,
            E85_73 = 73,
            E85_74 = 74,
            E85_75 = 75,
            E85_76 = 76,
            E85_77 = 77,
            E85_78 = 78,
            E85_79 = 79,
            E85_80 = 80,
            E85_81 = 81,
            E85_82 = 82,
            E85_83 = 83,
            E85_84 = 84,
        }

        private enum E86 : int
        {
            E86_0 = 0,
            E86_1 = 1,
            E86_2 = 2,
            E86_3 = 3,
            E86_4 = 4,
            E86_5 = 5,
            E86_6 = 6,
            E86_7 = 7,
            E86_8 = 8,
            E86_9 = 9,
            E86_10 = 10,
            E86_11 = 11,
            E86_12 = 12,
            E86_13 = 13,
            E86_14 = 14,
            E86_15 = 15,
            E86_16 = 16,
            E86_17 = 17,
            E86_18 = 18,
            E86_19 = 19,
            E86_20 = 20,
            E86_21 = 21,
            E86_22 = 22,
            E86_23 = 23,
            E86_24 = 24,
            E86_25 = 25,
            E86_26 = 26,
            E86_27 = 27,
            E86_28 = 28,
            E86_29 = 29,
            E86_30 = 30,
            E86_31 = 31,
            E86_32 = 32,
            E86_33 = 33,
            E86_34 = 34,
            E86_35 = 35,
            E86_36 = 36,
            E86_37 = 37,
            E86_38 = 38,
            E86_39 = 39,
            E86_40 = 40,
            E86_41 = 41,
            E86_42 = 42,
            E86_43 = 43,
            E86_44 = 44,
            E86_45 = 45,
            E86_46 = 46,
            E86_47 = 47,
            E86_48 = 48,
            E86_49 = 49,
            E86_50 = 50,
            E86_51 = 51,
            E86_52 = 52,
            E86_53 = 53,
            E86_54 = 54,
            E86_55 = 55,
            E86_56 = 56,
            E86_57 = 57,
            E86_58 = 58,
            E86_59 = 59,
            E86_60 = 60,
            E86_61 = 61,
            E86_62 = 62,
            E86_63 = 63,
            E86_64 = 64,
            E86_65 = 65,
            E86_66 = 66,
            E86_67 = 67,
            E86_68 = 68,
            E86_69 = 69,
            E86_70 = 70,
            E86_71 = 71,
            E86_72 = 72,
            E86_73 = 73,
            E86_74 = 74,
            E86_75 = 75,
            E86_76 = 76,
            E86_77 = 77,
            E86_78 = 78,
            E86_79 = 79,
            E86_80 = 80,
            E86_81 = 81,
            E86_82 = 82,
            E86_83 = 83,
            E86_84 = 84,
            E86_85 = 85,
        }

        private enum E87 : int
        {
            E87_0 = 0,
            E87_1 = 1,
            E87_2 = 2,
            E87_3 = 3,
            E87_4 = 4,
            E87_5 = 5,
            E87_6 = 6,
            E87_7 = 7,
            E87_8 = 8,
            E87_9 = 9,
            E87_10 = 10,
            E87_11 = 11,
            E87_12 = 12,
            E87_13 = 13,
            E87_14 = 14,
            E87_15 = 15,
            E87_16 = 16,
            E87_17 = 17,
            E87_18 = 18,
            E87_19 = 19,
            E87_20 = 20,
            E87_21 = 21,
            E87_22 = 22,
            E87_23 = 23,
            E87_24 = 24,
            E87_25 = 25,
            E87_26 = 26,
            E87_27 = 27,
            E87_28 = 28,
            E87_29 = 29,
            E87_30 = 30,
            E87_31 = 31,
            E87_32 = 32,
            E87_33 = 33,
            E87_34 = 34,
            E87_35 = 35,
            E87_36 = 36,
            E87_37 = 37,
            E87_38 = 38,
            E87_39 = 39,
            E87_40 = 40,
            E87_41 = 41,
            E87_42 = 42,
            E87_43 = 43,
            E87_44 = 44,
            E87_45 = 45,
            E87_46 = 46,
            E87_47 = 47,
            E87_48 = 48,
            E87_49 = 49,
            E87_50 = 50,
            E87_51 = 51,
            E87_52 = 52,
            E87_53 = 53,
            E87_54 = 54,
            E87_55 = 55,
            E87_56 = 56,
            E87_57 = 57,
            E87_58 = 58,
            E87_59 = 59,
            E87_60 = 60,
            E87_61 = 61,
            E87_62 = 62,
            E87_63 = 63,
            E87_64 = 64,
            E87_65 = 65,
            E87_66 = 66,
            E87_67 = 67,
            E87_68 = 68,
            E87_69 = 69,
            E87_70 = 70,
            E87_71 = 71,
            E87_72 = 72,
            E87_73 = 73,
            E87_74 = 74,
            E87_75 = 75,
            E87_76 = 76,
            E87_77 = 77,
            E87_78 = 78,
            E87_79 = 79,
            E87_80 = 80,
            E87_81 = 81,
            E87_82 = 82,
            E87_83 = 83,
            E87_84 = 84,
            E87_85 = 85,
            E87_86 = 86,
        }

        private enum E88 : int
        {
            E88_0 = 0,
            E88_1 = 1,
            E88_2 = 2,
            E88_3 = 3,
            E88_4 = 4,
            E88_5 = 5,
            E88_6 = 6,
            E88_7 = 7,
            E88_8 = 8,
            E88_9 = 9,
            E88_10 = 10,
            E88_11 = 11,
            E88_12 = 12,
            E88_13 = 13,
            E88_14 = 14,
            E88_15 = 15,
            E88_16 = 16,
            E88_17 = 17,
            E88_18 = 18,
            E88_19 = 19,
            E88_20 = 20,
            E88_21 = 21,
            E88_22 = 22,
            E88_23 = 23,
            E88_24 = 24,
            E88_25 = 25,
            E88_26 = 26,
            E88_27 = 27,
            E88_28 = 28,
            E88_29 = 29,
            E88_30 = 30,
            E88_31 = 31,
            E88_32 = 32,
            E88_33 = 33,
            E88_34 = 34,
            E88_35 = 35,
            E88_36 = 36,
            E88_37 = 37,
            E88_38 = 38,
            E88_39 = 39,
            E88_40 = 40,
            E88_41 = 41,
            E88_42 = 42,
            E88_43 = 43,
            E88_44 = 44,
            E88_45 = 45,
            E88_46 = 46,
            E88_47 = 47,
            E88_48 = 48,
            E88_49 = 49,
            E88_50 = 50,
            E88_51 = 51,
            E88_52 = 52,
            E88_53 = 53,
            E88_54 = 54,
            E88_55 = 55,
            E88_56 = 56,
            E88_57 = 57,
            E88_58 = 58,
            E88_59 = 59,
            E88_60 = 60,
            E88_61 = 61,
            E88_62 = 62,
            E88_63 = 63,
            E88_64 = 64,
            E88_65 = 65,
            E88_66 = 66,
            E88_67 = 67,
            E88_68 = 68,
            E88_69 = 69,
            E88_70 = 70,
            E88_71 = 71,
            E88_72 = 72,
            E88_73 = 73,
            E88_74 = 74,
            E88_75 = 75,
            E88_76 = 76,
            E88_77 = 77,
            E88_78 = 78,
            E88_79 = 79,
            E88_80 = 80,
            E88_81 = 81,
            E88_82 = 82,
            E88_83 = 83,
            E88_84 = 84,
            E88_85 = 85,
            E88_86 = 86,
            E88_87 = 87,
        }

        private enum E89 : int
        {
            E89_0 = 0,
            E89_1 = 1,
            E89_2 = 2,
            E89_3 = 3,
            E89_4 = 4,
            E89_5 = 5,
            E89_6 = 6,
            E89_7 = 7,
            E89_8 = 8,
            E89_9 = 9,
            E89_10 = 10,
            E89_11 = 11,
            E89_12 = 12,
            E89_13 = 13,
            E89_14 = 14,
            E89_15 = 15,
            E89_16 = 16,
            E89_17 = 17,
            E89_18 = 18,
            E89_19 = 19,
            E89_20 = 20,
            E89_21 = 21,
            E89_22 = 22,
            E89_23 = 23,
            E89_24 = 24,
            E89_25 = 25,
            E89_26 = 26,
            E89_27 = 27,
            E89_28 = 28,
            E89_29 = 29,
            E89_30 = 30,
            E89_31 = 31,
            E89_32 = 32,
            E89_33 = 33,
            E89_34 = 34,
            E89_35 = 35,
            E89_36 = 36,
            E89_37 = 37,
            E89_38 = 38,
            E89_39 = 39,
            E89_40 = 40,
            E89_41 = 41,
            E89_42 = 42,
            E89_43 = 43,
            E89_44 = 44,
            E89_45 = 45,
            E89_46 = 46,
            E89_47 = 47,
            E89_48 = 48,
            E89_49 = 49,
            E89_50 = 50,
            E89_51 = 51,
            E89_52 = 52,
            E89_53 = 53,
            E89_54 = 54,
            E89_55 = 55,
            E89_56 = 56,
            E89_57 = 57,
            E89_58 = 58,
            E89_59 = 59,
            E89_60 = 60,
            E89_61 = 61,
            E89_62 = 62,
            E89_63 = 63,
            E89_64 = 64,
            E89_65 = 65,
            E89_66 = 66,
            E89_67 = 67,
            E89_68 = 68,
            E89_69 = 69,
            E89_70 = 70,
            E89_71 = 71,
            E89_72 = 72,
            E89_73 = 73,
            E89_74 = 74,
            E89_75 = 75,
            E89_76 = 76,
            E89_77 = 77,
            E89_78 = 78,
            E89_79 = 79,
            E89_80 = 80,
            E89_81 = 81,
            E89_82 = 82,
            E89_83 = 83,
            E89_84 = 84,
            E89_85 = 85,
            E89_86 = 86,
            E89_87 = 87,
            E89_88 = 88,
        }

        private enum E90 : int
        {
            E90_0 = 0,
            E90_1 = 1,
            E90_2 = 2,
            E90_3 = 3,
            E90_4 = 4,
            E90_5 = 5,
            E90_6 = 6,
            E90_7 = 7,
            E90_8 = 8,
            E90_9 = 9,
            E90_10 = 10,
            E90_11 = 11,
            E90_12 = 12,
            E90_13 = 13,
            E90_14 = 14,
            E90_15 = 15,
            E90_16 = 16,
            E90_17 = 17,
            E90_18 = 18,
            E90_19 = 19,
            E90_20 = 20,
            E90_21 = 21,
            E90_22 = 22,
            E90_23 = 23,
            E90_24 = 24,
            E90_25 = 25,
            E90_26 = 26,
            E90_27 = 27,
            E90_28 = 28,
            E90_29 = 29,
            E90_30 = 30,
            E90_31 = 31,
            E90_32 = 32,
            E90_33 = 33,
            E90_34 = 34,
            E90_35 = 35,
            E90_36 = 36,
            E90_37 = 37,
            E90_38 = 38,
            E90_39 = 39,
            E90_40 = 40,
            E90_41 = 41,
            E90_42 = 42,
            E90_43 = 43,
            E90_44 = 44,
            E90_45 = 45,
            E90_46 = 46,
            E90_47 = 47,
            E90_48 = 48,
            E90_49 = 49,
            E90_50 = 50,
            E90_51 = 51,
            E90_52 = 52,
            E90_53 = 53,
            E90_54 = 54,
            E90_55 = 55,
            E90_56 = 56,
            E90_57 = 57,
            E90_58 = 58,
            E90_59 = 59,
            E90_60 = 60,
            E90_61 = 61,
            E90_62 = 62,
            E90_63 = 63,
            E90_64 = 64,
            E90_65 = 65,
            E90_66 = 66,
            E90_67 = 67,
            E90_68 = 68,
            E90_69 = 69,
            E90_70 = 70,
            E90_71 = 71,
            E90_72 = 72,
            E90_73 = 73,
            E90_74 = 74,
            E90_75 = 75,
            E90_76 = 76,
            E90_77 = 77,
            E90_78 = 78,
            E90_79 = 79,
            E90_80 = 80,
            E90_81 = 81,
            E90_82 = 82,
            E90_83 = 83,
            E90_84 = 84,
            E90_85 = 85,
            E90_86 = 86,
            E90_87 = 87,
            E90_88 = 88,
            E90_89 = 89,
        }

        private enum E91 : int
        {
            E91_0 = 0,
            E91_1 = 1,
            E91_2 = 2,
            E91_3 = 3,
            E91_4 = 4,
            E91_5 = 5,
            E91_6 = 6,
            E91_7 = 7,
            E91_8 = 8,
            E91_9 = 9,
            E91_10 = 10,
            E91_11 = 11,
            E91_12 = 12,
            E91_13 = 13,
            E91_14 = 14,
            E91_15 = 15,
            E91_16 = 16,
            E91_17 = 17,
            E91_18 = 18,
            E91_19 = 19,
            E91_20 = 20,
            E91_21 = 21,
            E91_22 = 22,
            E91_23 = 23,
            E91_24 = 24,
            E91_25 = 25,
            E91_26 = 26,
            E91_27 = 27,
            E91_28 = 28,
            E91_29 = 29,
            E91_30 = 30,
            E91_31 = 31,
            E91_32 = 32,
            E91_33 = 33,
            E91_34 = 34,
            E91_35 = 35,
            E91_36 = 36,
            E91_37 = 37,
            E91_38 = 38,
            E91_39 = 39,
            E91_40 = 40,
            E91_41 = 41,
            E91_42 = 42,
            E91_43 = 43,
            E91_44 = 44,
            E91_45 = 45,
            E91_46 = 46,
            E91_47 = 47,
            E91_48 = 48,
            E91_49 = 49,
            E91_50 = 50,
            E91_51 = 51,
            E91_52 = 52,
            E91_53 = 53,
            E91_54 = 54,
            E91_55 = 55,
            E91_56 = 56,
            E91_57 = 57,
            E91_58 = 58,
            E91_59 = 59,
            E91_60 = 60,
            E91_61 = 61,
            E91_62 = 62,
            E91_63 = 63,
            E91_64 = 64,
            E91_65 = 65,
            E91_66 = 66,
            E91_67 = 67,
            E91_68 = 68,
            E91_69 = 69,
            E91_70 = 70,
            E91_71 = 71,
            E91_72 = 72,
            E91_73 = 73,
            E91_74 = 74,
            E91_75 = 75,
            E91_76 = 76,
            E91_77 = 77,
            E91_78 = 78,
            E91_79 = 79,
            E91_80 = 80,
            E91_81 = 81,
            E91_82 = 82,
            E91_83 = 83,
            E91_84 = 84,
            E91_85 = 85,
            E91_86 = 86,
            E91_87 = 87,
            E91_88 = 88,
            E91_89 = 89,
            E91_90 = 90,
        }

        private enum E92 : int
        {
            E92_0 = 0,
            E92_1 = 1,
            E92_2 = 2,
            E92_3 = 3,
            E92_4 = 4,
            E92_5 = 5,
            E92_6 = 6,
            E92_7 = 7,
            E92_8 = 8,
            E92_9 = 9,
            E92_10 = 10,
            E92_11 = 11,
            E92_12 = 12,
            E92_13 = 13,
            E92_14 = 14,
            E92_15 = 15,
            E92_16 = 16,
            E92_17 = 17,
            E92_18 = 18,
            E92_19 = 19,
            E92_20 = 20,
            E92_21 = 21,
            E92_22 = 22,
            E92_23 = 23,
            E92_24 = 24,
            E92_25 = 25,
            E92_26 = 26,
            E92_27 = 27,
            E92_28 = 28,
            E92_29 = 29,
            E92_30 = 30,
            E92_31 = 31,
            E92_32 = 32,
            E92_33 = 33,
            E92_34 = 34,
            E92_35 = 35,
            E92_36 = 36,
            E92_37 = 37,
            E92_38 = 38,
            E92_39 = 39,
            E92_40 = 40,
            E92_41 = 41,
            E92_42 = 42,
            E92_43 = 43,
            E92_44 = 44,
            E92_45 = 45,
            E92_46 = 46,
            E92_47 = 47,
            E92_48 = 48,
            E92_49 = 49,
            E92_50 = 50,
            E92_51 = 51,
            E92_52 = 52,
            E92_53 = 53,
            E92_54 = 54,
            E92_55 = 55,
            E92_56 = 56,
            E92_57 = 57,
            E92_58 = 58,
            E92_59 = 59,
            E92_60 = 60,
            E92_61 = 61,
            E92_62 = 62,
            E92_63 = 63,
            E92_64 = 64,
            E92_65 = 65,
            E92_66 = 66,
            E92_67 = 67,
            E92_68 = 68,
            E92_69 = 69,
            E92_70 = 70,
            E92_71 = 71,
            E92_72 = 72,
            E92_73 = 73,
            E92_74 = 74,
            E92_75 = 75,
            E92_76 = 76,
            E92_77 = 77,
            E92_78 = 78,
            E92_79 = 79,
            E92_80 = 80,
            E92_81 = 81,
            E92_82 = 82,
            E92_83 = 83,
            E92_84 = 84,
            E92_85 = 85,
            E92_86 = 86,
            E92_87 = 87,
            E92_88 = 88,
            E92_89 = 89,
            E92_90 = 90,
            E92_91 = 91,
        }

        private enum E93 : int
        {
            E93_0 = 0,
            E93_1 = 1,
            E93_2 = 2,
            E93_3 = 3,
            E93_4 = 4,
            E93_5 = 5,
            E93_6 = 6,
            E93_7 = 7,
            E93_8 = 8,
            E93_9 = 9,
            E93_10 = 10,
            E93_11 = 11,
            E93_12 = 12,
            E93_13 = 13,
            E93_14 = 14,
            E93_15 = 15,
            E93_16 = 16,
            E93_17 = 17,
            E93_18 = 18,
            E93_19 = 19,
            E93_20 = 20,
            E93_21 = 21,
            E93_22 = 22,
            E93_23 = 23,
            E93_24 = 24,
            E93_25 = 25,
            E93_26 = 26,
            E93_27 = 27,
            E93_28 = 28,
            E93_29 = 29,
            E93_30 = 30,
            E93_31 = 31,
            E93_32 = 32,
            E93_33 = 33,
            E93_34 = 34,
            E93_35 = 35,
            E93_36 = 36,
            E93_37 = 37,
            E93_38 = 38,
            E93_39 = 39,
            E93_40 = 40,
            E93_41 = 41,
            E93_42 = 42,
            E93_43 = 43,
            E93_44 = 44,
            E93_45 = 45,
            E93_46 = 46,
            E93_47 = 47,
            E93_48 = 48,
            E93_49 = 49,
            E93_50 = 50,
            E93_51 = 51,
            E93_52 = 52,
            E93_53 = 53,
            E93_54 = 54,
            E93_55 = 55,
            E93_56 = 56,
            E93_57 = 57,
            E93_58 = 58,
            E93_59 = 59,
            E93_60 = 60,
            E93_61 = 61,
            E93_62 = 62,
            E93_63 = 63,
            E93_64 = 64,
            E93_65 = 65,
            E93_66 = 66,
            E93_67 = 67,
            E93_68 = 68,
            E93_69 = 69,
            E93_70 = 70,
            E93_71 = 71,
            E93_72 = 72,
            E93_73 = 73,
            E93_74 = 74,
            E93_75 = 75,
            E93_76 = 76,
            E93_77 = 77,
            E93_78 = 78,
            E93_79 = 79,
            E93_80 = 80,
            E93_81 = 81,
            E93_82 = 82,
            E93_83 = 83,
            E93_84 = 84,
            E93_85 = 85,
            E93_86 = 86,
            E93_87 = 87,
            E93_88 = 88,
            E93_89 = 89,
            E93_90 = 90,
            E93_91 = 91,
            E93_92 = 92,
        }

        private enum E94 : int
        {
            E94_0 = 0,
            E94_1 = 1,
            E94_2 = 2,
            E94_3 = 3,
            E94_4 = 4,
            E94_5 = 5,
            E94_6 = 6,
            E94_7 = 7,
            E94_8 = 8,
            E94_9 = 9,
            E94_10 = 10,
            E94_11 = 11,
            E94_12 = 12,
            E94_13 = 13,
            E94_14 = 14,
            E94_15 = 15,
            E94_16 = 16,
            E94_17 = 17,
            E94_18 = 18,
            E94_19 = 19,
            E94_20 = 20,
            E94_21 = 21,
            E94_22 = 22,
            E94_23 = 23,
            E94_24 = 24,
            E94_25 = 25,
            E94_26 = 26,
            E94_27 = 27,
            E94_28 = 28,
            E94_29 = 29,
            E94_30 = 30,
            E94_31 = 31,
            E94_32 = 32,
            E94_33 = 33,
            E94_34 = 34,
            E94_35 = 35,
            E94_36 = 36,
            E94_37 = 37,
            E94_38 = 38,
            E94_39 = 39,
            E94_40 = 40,
            E94_41 = 41,
            E94_42 = 42,
            E94_43 = 43,
            E94_44 = 44,
            E94_45 = 45,
            E94_46 = 46,
            E94_47 = 47,
            E94_48 = 48,
            E94_49 = 49,
            E94_50 = 50,
            E94_51 = 51,
            E94_52 = 52,
            E94_53 = 53,
            E94_54 = 54,
            E94_55 = 55,
            E94_56 = 56,
            E94_57 = 57,
            E94_58 = 58,
            E94_59 = 59,
            E94_60 = 60,
            E94_61 = 61,
            E94_62 = 62,
            E94_63 = 63,
            E94_64 = 64,
            E94_65 = 65,
            E94_66 = 66,
            E94_67 = 67,
            E94_68 = 68,
            E94_69 = 69,
            E94_70 = 70,
            E94_71 = 71,
            E94_72 = 72,
            E94_73 = 73,
            E94_74 = 74,
            E94_75 = 75,
            E94_76 = 76,
            E94_77 = 77,
            E94_78 = 78,
            E94_79 = 79,
            E94_80 = 80,
            E94_81 = 81,
            E94_82 = 82,
            E94_83 = 83,
            E94_84 = 84,
            E94_85 = 85,
            E94_86 = 86,
            E94_87 = 87,
            E94_88 = 88,
            E94_89 = 89,
            E94_90 = 90,
            E94_91 = 91,
            E94_92 = 92,
            E94_93 = 93,
        }

        private enum E95 : int
        {
            E95_0 = 0,
            E95_1 = 1,
            E95_2 = 2,
            E95_3 = 3,
            E95_4 = 4,
            E95_5 = 5,
            E95_6 = 6,
            E95_7 = 7,
            E95_8 = 8,
            E95_9 = 9,
            E95_10 = 10,
            E95_11 = 11,
            E95_12 = 12,
            E95_13 = 13,
            E95_14 = 14,
            E95_15 = 15,
            E95_16 = 16,
            E95_17 = 17,
            E95_18 = 18,
            E95_19 = 19,
            E95_20 = 20,
            E95_21 = 21,
            E95_22 = 22,
            E95_23 = 23,
            E95_24 = 24,
            E95_25 = 25,
            E95_26 = 26,
            E95_27 = 27,
            E95_28 = 28,
            E95_29 = 29,
            E95_30 = 30,
            E95_31 = 31,
            E95_32 = 32,
            E95_33 = 33,
            E95_34 = 34,
            E95_35 = 35,
            E95_36 = 36,
            E95_37 = 37,
            E95_38 = 38,
            E95_39 = 39,
            E95_40 = 40,
            E95_41 = 41,
            E95_42 = 42,
            E95_43 = 43,
            E95_44 = 44,
            E95_45 = 45,
            E95_46 = 46,
            E95_47 = 47,
            E95_48 = 48,
            E95_49 = 49,
            E95_50 = 50,
            E95_51 = 51,
            E95_52 = 52,
            E95_53 = 53,
            E95_54 = 54,
            E95_55 = 55,
            E95_56 = 56,
            E95_57 = 57,
            E95_58 = 58,
            E95_59 = 59,
            E95_60 = 60,
            E95_61 = 61,
            E95_62 = 62,
            E95_63 = 63,
            E95_64 = 64,
            E95_65 = 65,
            E95_66 = 66,
            E95_67 = 67,
            E95_68 = 68,
            E95_69 = 69,
            E95_70 = 70,
            E95_71 = 71,
            E95_72 = 72,
            E95_73 = 73,
            E95_74 = 74,
            E95_75 = 75,
            E95_76 = 76,
            E95_77 = 77,
            E95_78 = 78,
            E95_79 = 79,
            E95_80 = 80,
            E95_81 = 81,
            E95_82 = 82,
            E95_83 = 83,
            E95_84 = 84,
            E95_85 = 85,
            E95_86 = 86,
            E95_87 = 87,
            E95_88 = 88,
            E95_89 = 89,
            E95_90 = 90,
            E95_91 = 91,
            E95_92 = 92,
            E95_93 = 93,
            E95_94 = 94,
        }

        private enum E96 : int
        {
            E96_0 = 0,
            E96_1 = 1,
            E96_2 = 2,
            E96_3 = 3,
            E96_4 = 4,
            E96_5 = 5,
            E96_6 = 6,
            E96_7 = 7,
            E96_8 = 8,
            E96_9 = 9,
            E96_10 = 10,
            E96_11 = 11,
            E96_12 = 12,
            E96_13 = 13,
            E96_14 = 14,
            E96_15 = 15,
            E96_16 = 16,
            E96_17 = 17,
            E96_18 = 18,
            E96_19 = 19,
            E96_20 = 20,
            E96_21 = 21,
            E96_22 = 22,
            E96_23 = 23,
            E96_24 = 24,
            E96_25 = 25,
            E96_26 = 26,
            E96_27 = 27,
            E96_28 = 28,
            E96_29 = 29,
            E96_30 = 30,
            E96_31 = 31,
            E96_32 = 32,
            E96_33 = 33,
            E96_34 = 34,
            E96_35 = 35,
            E96_36 = 36,
            E96_37 = 37,
            E96_38 = 38,
            E96_39 = 39,
            E96_40 = 40,
            E96_41 = 41,
            E96_42 = 42,
            E96_43 = 43,
            E96_44 = 44,
            E96_45 = 45,
            E96_46 = 46,
            E96_47 = 47,
            E96_48 = 48,
            E96_49 = 49,
            E96_50 = 50,
            E96_51 = 51,
            E96_52 = 52,
            E96_53 = 53,
            E96_54 = 54,
            E96_55 = 55,
            E96_56 = 56,
            E96_57 = 57,
            E96_58 = 58,
            E96_59 = 59,
            E96_60 = 60,
            E96_61 = 61,
            E96_62 = 62,
            E96_63 = 63,
            E96_64 = 64,
            E96_65 = 65,
            E96_66 = 66,
            E96_67 = 67,
            E96_68 = 68,
            E96_69 = 69,
            E96_70 = 70,
            E96_71 = 71,
            E96_72 = 72,
            E96_73 = 73,
            E96_74 = 74,
            E96_75 = 75,
            E96_76 = 76,
            E96_77 = 77,
            E96_78 = 78,
            E96_79 = 79,
            E96_80 = 80,
            E96_81 = 81,
            E96_82 = 82,
            E96_83 = 83,
            E96_84 = 84,
            E96_85 = 85,
            E96_86 = 86,
            E96_87 = 87,
            E96_88 = 88,
            E96_89 = 89,
            E96_90 = 90,
            E96_91 = 91,
            E96_92 = 92,
            E96_93 = 93,
            E96_94 = 94,
            E96_95 = 95,
        }

        private enum E97 : int
        {
            E97_0 = 0,
            E97_1 = 1,
            E97_2 = 2,
            E97_3 = 3,
            E97_4 = 4,
            E97_5 = 5,
            E97_6 = 6,
            E97_7 = 7,
            E97_8 = 8,
            E97_9 = 9,
            E97_10 = 10,
            E97_11 = 11,
            E97_12 = 12,
            E97_13 = 13,
            E97_14 = 14,
            E97_15 = 15,
            E97_16 = 16,
            E97_17 = 17,
            E97_18 = 18,
            E97_19 = 19,
            E97_20 = 20,
            E97_21 = 21,
            E97_22 = 22,
            E97_23 = 23,
            E97_24 = 24,
            E97_25 = 25,
            E97_26 = 26,
            E97_27 = 27,
            E97_28 = 28,
            E97_29 = 29,
            E97_30 = 30,
            E97_31 = 31,
            E97_32 = 32,
            E97_33 = 33,
            E97_34 = 34,
            E97_35 = 35,
            E97_36 = 36,
            E97_37 = 37,
            E97_38 = 38,
            E97_39 = 39,
            E97_40 = 40,
            E97_41 = 41,
            E97_42 = 42,
            E97_43 = 43,
            E97_44 = 44,
            E97_45 = 45,
            E97_46 = 46,
            E97_47 = 47,
            E97_48 = 48,
            E97_49 = 49,
            E97_50 = 50,
            E97_51 = 51,
            E97_52 = 52,
            E97_53 = 53,
            E97_54 = 54,
            E97_55 = 55,
            E97_56 = 56,
            E97_57 = 57,
            E97_58 = 58,
            E97_59 = 59,
            E97_60 = 60,
            E97_61 = 61,
            E97_62 = 62,
            E97_63 = 63,
            E97_64 = 64,
            E97_65 = 65,
            E97_66 = 66,
            E97_67 = 67,
            E97_68 = 68,
            E97_69 = 69,
            E97_70 = 70,
            E97_71 = 71,
            E97_72 = 72,
            E97_73 = 73,
            E97_74 = 74,
            E97_75 = 75,
            E97_76 = 76,
            E97_77 = 77,
            E97_78 = 78,
            E97_79 = 79,
            E97_80 = 80,
            E97_81 = 81,
            E97_82 = 82,
            E97_83 = 83,
            E97_84 = 84,
            E97_85 = 85,
            E97_86 = 86,
            E97_87 = 87,
            E97_88 = 88,
            E97_89 = 89,
            E97_90 = 90,
            E97_91 = 91,
            E97_92 = 92,
            E97_93 = 93,
            E97_94 = 94,
            E97_95 = 95,
            E97_96 = 96,
        }

        private enum E98 : int
        {
            E98_0 = 0,
            E98_1 = 1,
            E98_2 = 2,
            E98_3 = 3,
            E98_4 = 4,
            E98_5 = 5,
            E98_6 = 6,
            E98_7 = 7,
            E98_8 = 8,
            E98_9 = 9,
            E98_10 = 10,
            E98_11 = 11,
            E98_12 = 12,
            E98_13 = 13,
            E98_14 = 14,
            E98_15 = 15,
            E98_16 = 16,
            E98_17 = 17,
            E98_18 = 18,
            E98_19 = 19,
            E98_20 = 20,
            E98_21 = 21,
            E98_22 = 22,
            E98_23 = 23,
            E98_24 = 24,
            E98_25 = 25,
            E98_26 = 26,
            E98_27 = 27,
            E98_28 = 28,
            E98_29 = 29,
            E98_30 = 30,
            E98_31 = 31,
            E98_32 = 32,
            E98_33 = 33,
            E98_34 = 34,
            E98_35 = 35,
            E98_36 = 36,
            E98_37 = 37,
            E98_38 = 38,
            E98_39 = 39,
            E98_40 = 40,
            E98_41 = 41,
            E98_42 = 42,
            E98_43 = 43,
            E98_44 = 44,
            E98_45 = 45,
            E98_46 = 46,
            E98_47 = 47,
            E98_48 = 48,
            E98_49 = 49,
            E98_50 = 50,
            E98_51 = 51,
            E98_52 = 52,
            E98_53 = 53,
            E98_54 = 54,
            E98_55 = 55,
            E98_56 = 56,
            E98_57 = 57,
            E98_58 = 58,
            E98_59 = 59,
            E98_60 = 60,
            E98_61 = 61,
            E98_62 = 62,
            E98_63 = 63,
            E98_64 = 64,
            E98_65 = 65,
            E98_66 = 66,
            E98_67 = 67,
            E98_68 = 68,
            E98_69 = 69,
            E98_70 = 70,
            E98_71 = 71,
            E98_72 = 72,
            E98_73 = 73,
            E98_74 = 74,
            E98_75 = 75,
            E98_76 = 76,
            E98_77 = 77,
            E98_78 = 78,
            E98_79 = 79,
            E98_80 = 80,
            E98_81 = 81,
            E98_82 = 82,
            E98_83 = 83,
            E98_84 = 84,
            E98_85 = 85,
            E98_86 = 86,
            E98_87 = 87,
            E98_88 = 88,
            E98_89 = 89,
            E98_90 = 90,
            E98_91 = 91,
            E98_92 = 92,
            E98_93 = 93,
            E98_94 = 94,
            E98_95 = 95,
            E98_96 = 96,
            E98_97 = 97,
        }

        private enum E99 : int
        {
            E99_0 = 0,
            E99_1 = 1,
            E99_2 = 2,
            E99_3 = 3,
            E99_4 = 4,
            E99_5 = 5,
            E99_6 = 6,
            E99_7 = 7,
            E99_8 = 8,
            E99_9 = 9,
            E99_10 = 10,
            E99_11 = 11,
            E99_12 = 12,
            E99_13 = 13,
            E99_14 = 14,
            E99_15 = 15,
            E99_16 = 16,
            E99_17 = 17,
            E99_18 = 18,
            E99_19 = 19,
            E99_20 = 20,
            E99_21 = 21,
            E99_22 = 22,
            E99_23 = 23,
            E99_24 = 24,
            E99_25 = 25,
            E99_26 = 26,
            E99_27 = 27,
            E99_28 = 28,
            E99_29 = 29,
            E99_30 = 30,
            E99_31 = 31,
            E99_32 = 32,
            E99_33 = 33,
            E99_34 = 34,
            E99_35 = 35,
            E99_36 = 36,
            E99_37 = 37,
            E99_38 = 38,
            E99_39 = 39,
            E99_40 = 40,
            E99_41 = 41,
            E99_42 = 42,
            E99_43 = 43,
            E99_44 = 44,
            E99_45 = 45,
            E99_46 = 46,
            E99_47 = 47,
            E99_48 = 48,
            E99_49 = 49,
            E99_50 = 50,
            E99_51 = 51,
            E99_52 = 52,
            E99_53 = 53,
            E99_54 = 54,
            E99_55 = 55,
            E99_56 = 56,
            E99_57 = 57,
            E99_58 = 58,
            E99_59 = 59,
            E99_60 = 60,
            E99_61 = 61,
            E99_62 = 62,
            E99_63 = 63,
            E99_64 = 64,
            E99_65 = 65,
            E99_66 = 66,
            E99_67 = 67,
            E99_68 = 68,
            E99_69 = 69,
            E99_70 = 70,
            E99_71 = 71,
            E99_72 = 72,
            E99_73 = 73,
            E99_74 = 74,
            E99_75 = 75,
            E99_76 = 76,
            E99_77 = 77,
            E99_78 = 78,
            E99_79 = 79,
            E99_80 = 80,
            E99_81 = 81,
            E99_82 = 82,
            E99_83 = 83,
            E99_84 = 84,
            E99_85 = 85,
            E99_86 = 86,
            E99_87 = 87,
            E99_88 = 88,
            E99_89 = 89,
            E99_90 = 90,
            E99_91 = 91,
            E99_92 = 92,
            E99_93 = 93,
            E99_94 = 94,
            E99_95 = 95,
            E99_96 = 96,
            E99_97 = 97,
            E99_98 = 98,
        }

    }
}
